Can't find htonl with inet.h or in.h

This is a discussion on Can't find htonl with inet.h or in.h within the C Programming forums, part of the General Programming Boards category; Good morning. I'm reading a code for LZ77 compression but htonl and other network functions can't be recognized (I get ...

  1. #1
    Tears of the stars thames's Avatar
    Join Date
    Oct 2012
    Location
    Rio, Brazil
    Posts
    193

    Question Can't find htonl with inet.h or in.h

    Good morning. I'm reading a code for LZ77 compression but htonl and other network functions can't be recognized (I get that unresolved identifier problem) even including

    Code:
    #include <arpa/inet.h>
    or

    Code:
     
    #include <netinet/in.h>
    I already took a look into the library and I realized I have those headers. also, all the other headers were properly created for the project.

    Code:
     
    /*****************************************************************************
    *                                                                            *
    *  -------------------------------- lz77.c --------------------------------  *
    *                                                                            *
    *****************************************************************************/
    
    #include <netinet/in.h>
    #include <stdlib.h>
    #include <string.h>
    
    #include "bit.h"
    #include "compress.h"
    
    /*****************************************************************************
    *                                                                            *
    *  ------------------------------ compare_win -----------------------------  *
    *                                                                            *
    *****************************************************************************/
    
    static int compare_win(const unsigned char *window, const unsigned char
       *buffer, int *offset, unsigned char *next) {
    
    int                match,
                       longest,
                       i,
                       j,
                       k;
    
    /*****************************************************************************
    *                                                                            *
    *  Initialize the offset, although it is valid only once a match is found.   *
    *                                                                            *
    *****************************************************************************/
    
    *offset = 0;
    
    /*****************************************************************************
    *                                                                            *
    *  If no match is found, prepare to return 0 and the next symbol in the      *
    *  look-ahead buffer.                                                        *
    *                                                                            *
    *****************************************************************************/
    
    longest = 0;
    *next = buffer[0];
    
    /*****************************************************************************
    *                                                                            *
    *  Look for the best match in the look-ahead buffer and sliding window.      *
    *                                                                            *
    *****************************************************************************/
    
    for (k = 0; k < LZ77_WINDOW_SIZE; k++) {
    
       i = k;
       j = 0;
       match = 0;
    
       /**************************************************************************
       *                                                                         *
       *  Determine how many symbols match in the sliding window at offset k.    *
       *                                                                         *
       **************************************************************************/
    
       while (i < LZ77_WINDOW_SIZE && j < LZ77_BUFFER_SIZE - 1) {
    
          if (window[i] != buffer[j])
             break;
    
          match++;
          i++;
          j++;
    
       }
    
       /**************************************************************************
       *                                                                         *
       *  Keep track of the offset, length, and next symbol for the best match.  *
       *                                                                         *
       **************************************************************************/
    
       if (match > longest) {
    
          *offset = k;
          longest = match;
          *next = buffer[j];
    
       }
    
    }
    
    return longest;
    
    }
    
    /*****************************************************************************
    *                                                                            *
    *  ----------------------------- lz77_compress ----------------------------  *
    *                                                                            *
    *****************************************************************************/
    
    int lz77_compress(const unsigned char *original, unsigned char **compressed,
       int size) {
    
    unsigned long      token;
    
    unsigned char      window[LZ77_WINDOW_SIZE],
                       buffer[LZ77_BUFFER_SIZE],
                       *comp,
                       *temp,
                       next;
    
    int                offset,
                       length,
                       remaining,
                       tbits,
                       hsize,
                       ipos,
                       opos,
                       tpos,
                       i;
    
    /*****************************************************************************
    *                                                                            *
    *  Make the pointer to the compressed data not valid until later.            *
    *                                                                            *
    *****************************************************************************/
    
    *compressed = NULL;
    
    /*****************************************************************************
    *                                                                            *
    *  Write the header information.                                             *
    *                                                                            *
    *****************************************************************************/
    
    hsize = sizeof(int);
    
    if ((comp = (unsigned char *)malloc(hsize)) == NULL)
       return -1;
    
    memcpy(comp, &size, sizeof(int));
    
    /*****************************************************************************
    *                                                                            *
    *  Initialize the sliding window and the look-ahead buffer.                  *
    *                                                                            *
    *****************************************************************************/
    
    memset(window, 0, LZ77_WINDOW_SIZE);
    memset(buffer, 0, LZ77_BUFFER_SIZE);
    
    /*****************************************************************************
    *                                                                            *
    *  Load the look-ahead buffer.                                               *
    *                                                                            *
    *****************************************************************************/
    
    ipos = 0;
    
    for (i = 0; i < LZ77_BUFFER_SIZE && ipos < size; i++) {
    
       buffer[i] = original[ipos];
       ipos++;
    
    }
    
    /*****************************************************************************
    *                                                                            *
    *  Compress the data.                                                        *
    *                                                                            *
    *****************************************************************************/
    
    opos = hsize * 8;
    remaining = size;
    
    while (remaining > 0) {
    
       if ((length = compare_win(window, buffer, &offset, &next)) != 0) {
    
          /***********************************************************************
          *                                                                      *
          *  Encode a phrase token.                                              *
          *                                                                      *
          ***********************************************************************/
    
          token = 0x00000001 << (LZ77_PHRASE_BITS - 1);
    
          /***********************************************************************
          *                                                                      *
          *  Set the offset where the match was found in the sliding window.     *
          *                                                                      *
          ***********************************************************************/
    
          token = token | (offset << (LZ77_PHRASE_BITS - LZ77_TYPE_BITS -
             LZ77_WINOFF_BITS));
    
          /***********************************************************************
          *                                                                      *
          *  Set the length of the match.                                        *
          *                                                                      *
          ***********************************************************************/
    
          token = token | (length << (LZ77_PHRASE_BITS - LZ77_TYPE_BITS -
             LZ77_WINOFF_BITS - LZ77_BUFLEN_BITS));
    
          /***********************************************************************
          *                                                                      *
          *  Set the next symbol in the look-ahead buffer after the match.       *
          *                                                                      *
          ***********************************************************************/
    
          token = token | next;
    
          /***********************************************************************
          *                                                                      *
          *  Set the number of bits in the token.                                *
          *                                                                      *
          ***********************************************************************/
    
          tbits = LZ77_PHRASE_BITS;
          
          }
    
       else {
    
          /***********************************************************************
          *                                                                      *
          *  Encode a symbol token.                                              *
          *                                                                      *
          ***********************************************************************/
    
          token = 0x00000000;
    
          /***********************************************************************
          *                                                                      *
          *  Set the unmatched symbol.                                           *
          *                                                                      *
          ***********************************************************************/
    
          token = token | next;
    
          /***********************************************************************
          *                                                                      *
          *  Set the number of bits in the token.                                *
          *                                                                      *
          ***********************************************************************/
    
          tbits = LZ77_SYMBOL_BITS;
    
       }
    
       /**************************************************************************
       *                                                                         *
       *  Ensure that the token is in big-endian format.                         *
       *                                                                         *
       **************************************************************************/
    
       token = htonl(token);
    
       /**************************************************************************
       *                                                                         *
       *  Write the token to the buffer of compressed data.                      *
       *                                                                         *
       **************************************************************************/
    
       for (i = 0; i < tbits; i++) {
    
          if (opos % 8 == 0) {
    
             /********************************************************************
             *                                                                   *
             *  Allocate another byte for the buffer of compressed data.         *
             *                                                                   *
             ********************************************************************/
    
             if ((temp = (unsigned char *)realloc(comp,(opos / 8) + 1)) == NULL) {
    
                free(comp);
                return -1;
    
             }
    
             comp = temp;
    
          }
    
          tpos = (sizeof(unsigned long) * 8) - tbits + i;
          bit_set(comp, opos, bit_get((unsigned char *)&token, tpos));
          opos++;
    
       }
    
       /**************************************************************************
       *                                                                         *
       *  Adjust the phrase length to account for the unmatched symbol.          *
       *                                                                         *
       **************************************************************************/
    
       length++;
          
       /**************************************************************************
       *                                                                         *
       *  Copy data from the look-ahead buffer to the sliding window.            *
       *                                                                         *
       **************************************************************************/
    
       memmove(&window[0], &window[length], LZ77_WINDOW_SIZE - length);
       memmove(&window[LZ77_WINDOW_SIZE - length], &buffer[0], length);
    
       /**************************************************************************
       *                                                                         *
       *  Read more data into the look-ahead buffer.                             *
       *                                                                         *
       **************************************************************************/
    
       memmove(&buffer[0], &buffer[length], LZ77_BUFFER_SIZE - length);
    
       for (i = LZ77_BUFFER_SIZE - length; i<LZ77_BUFFER_SIZE && ipos<size; i++) {
    
          buffer[i] = original[ipos];
          ipos++;
    
       }
    
       /**************************************************************************
       *                                                                         *
       *  Adjust the total symbols remaining by the phrase length.               *
       *                                                                         *
       **************************************************************************/
    
       remaining = remaining - length;
    
    }
    
    /*****************************************************************************
    *                                                                            *
    *  Point to the buffer of compressed data.                                   *
    *                                                                            *
    *****************************************************************************/
    
    *compressed = comp;
    
    /*****************************************************************************
    *                                                                            *
    *  Return the number of bytes in the compressed data.                        *
    *                                                                            *
    *****************************************************************************/
    
    return ((opos - 1) / 8) + 1;
    
    }
    
    /*****************************************************************************
    *                                                                            *
    *  ---------------------------- lz77_uncompress ---------------------------  *
    *                                                                            *
    *****************************************************************************/
    
    int lz77_uncompress(const unsigned char *compressed, unsigned char
       **original) {
    
    unsigned char      window[LZ77_WINDOW_SIZE],
                       buffer[LZ77_BUFFER_SIZE],
                       *orig,
                       *temp,
                       next;
    
    int                offset,
                       length,
                       remaining,
                       hsize,
                       size,
                       ipos,
                       opos,
                       tpos,
                       state,
                       i;
    
    /*****************************************************************************
    *                                                                            *
    *  Make the pointer to the original data not valid until later.              *
    *                                                                            *
    *****************************************************************************/
    
    *original = orig = NULL;
    
    /*****************************************************************************
    *                                                                            *
    *  Get the header information.                                               *
    *                                                                            *
    *****************************************************************************/
    
    hsize = sizeof(int);
    memcpy(&size, compressed, sizeof(int));
    
    /*****************************************************************************
    *                                                                            *
    *  Initialize the sliding window and the look-ahead buffer.                  *
    *                                                                            *
    *****************************************************************************/
    
    memset(window, 0, LZ77_WINDOW_SIZE);
    memset(buffer, 0, LZ77_BUFFER_SIZE);
    
    /*****************************************************************************
    *                                                                            *
    *  Uncompress the data.                                                      *
    *                                                                            *
    *****************************************************************************/
    
    ipos = hsize * 8;
    opos = 0;
    remaining = size;
    
    while (remaining > 0) {
    
       /**************************************************************************
       *                                                                         *
       *  Get the next bit in the compressed data.                               *
       *                                                                         *
       **************************************************************************/
    
       state = bit_get(compressed, ipos);
       ipos++;
    
       if (state == 1) {
    
          /***********************************************************************
          *                                                                      *
          *  Handle processing a phrase token.                                   *
          *                                                                      *
          ***********************************************************************/
    
          memset(&offset, 0, sizeof(int));
    
          for (i = 0; i < LZ77_WINOFF_BITS; i++) {
    
             tpos = (sizeof(int) * 8) - LZ77_WINOFF_BITS + i;
             bit_set((unsigned char *)&offset, tpos, bit_get(compressed, ipos));
             ipos++;
    
          }
    
          memset(&length, 0, sizeof(int));
    
          for (i = 0; i < LZ77_BUFLEN_BITS; i++) {
    
             tpos = (sizeof(int) * 8) - LZ77_BUFLEN_BITS + i;
             bit_set((unsigned char *)&length, tpos, bit_get(compressed, ipos));
             ipos++;
    
          }
    
          next = 0x00;
    
          for (i = 0; i < LZ77_NEXT_BITS; i++) {
    
             tpos = (sizeof(unsigned char) * 8) - LZ77_NEXT_BITS + i;
             bit_set((unsigned char *)&next, tpos, bit_get(compressed, ipos));
             ipos++;
    
          }
    
          /***********************************************************************
          *                                                                      *
          *  Ensure that the offset and length have the correct byte ordering    *
          *  for the system.                                                     *
          *                                                                      *
          ***********************************************************************/
    
          offset = ntohl(offset);
          length = ntohl(length);
    
          /***********************************************************************
          *                                                                      *
          *  Write the phrase from the window to the buffer of original data.    *
          *                                                                      *
          ***********************************************************************/
    
          i = 0;
    
          if (opos > 0) {
    
             if ((temp = (unsigned char *)realloc(orig, opos+length+1)) == NULL) {
    
                free(orig);
                return -1;
    
             }
    
             orig = temp;
    
             }
    
          else {
    
             if ((orig = (unsigned char *)malloc(length + 1)) == NULL)
                return -1;
    
          }
    
          while (i < length && remaining > 0) {
    
             orig[opos] = window[offset + i];
             opos++;
    
             /********************************************************************
             *                                                                   *
             *  Record each symbol in the look-ahead buffer until ready to       *
             *  update the sliding window.                                       *
             *                                                                   *
             ********************************************************************/
    
             buffer[i] = window[offset + i];
             i++;
    
             /********************************************************************
             *                                                                   *
             *  Adjust the total symbols remaining to account for each symbol    *
             *  consumed.                                                        *
             *                                                                   *
             ********************************************************************/
    
             remaining--;
    
          }
    
          /***********************************************************************
          *                                                                      *
          *  Write the unmatched symbol to the buffer of original data.          *
          *                                                                      *
          ***********************************************************************/
    
          if (remaining > 0) {
    
             orig[opos] = next;
             opos++;
    
             /********************************************************************
             *                                                                   *
             *  Also record this symbol in the look-ahead buffer.                *
             *                                                                   *
             ********************************************************************/
    
             buffer[i] = next;
    
             /********************************************************************
             *                                                                   *
             *  Adjust the total symbols remaining to account for the unmatched  *
             *  symbol.                                                          *
             *                                                                   *
             ********************************************************************/
    
             remaining--;
    
          }
    
          /***********************************************************************
          *                                                                      *
          *  Adjust the phrase length to account for the unmatched symbol.       *
          *                                                                      *
          ***********************************************************************/
    
          length++;
    
          }
    
       else {
    
          /***********************************************************************
          *                                                                      *
          *  Handle processing a symbol token.                                   *
          *                                                                      *
          ***********************************************************************/
    
          next = 0x00;
    
          for (i = 0; i < LZ77_NEXT_BITS; i++) {
    
             tpos = (sizeof(unsigned char) * 8) - LZ77_NEXT_BITS + i;
             bit_set((unsigned char *)&next, tpos, bit_get(compressed, ipos));
             ipos++;
    
          }
    
          /***********************************************************************
          *                                                                      *
          *  Write the symbol to the buffer of original data.                    *
          *                                                                      *
          ***********************************************************************/
    
          if (opos > 0) {
    
             if ((temp = (unsigned char *)realloc(orig, opos + 1)) == NULL) {
    
                free(orig);
                return -1;
    
             }
    
             orig = temp;
    
             }
    
          else {
    
             if ((orig = (unsigned char *)malloc(1)) == NULL)
                return -1;
    
          }
    
          orig[opos] = next;
          opos++;
    
          /***********************************************************************
          *                                                                      *
          *  Record the symbol in the look-ahead buffer until ready to update    *
          *  the sliding window.                                                 *
          *                                                                      *
          ***********************************************************************/
    
          if (remaining > 0)
             buffer[0] = next;
    
          /***********************************************************************
          *                                                                      *
          *  Adjust the total symbols remaining to account for the unmatched     *
          *  symbol.                                                             *
          *                                                                      *
          ***********************************************************************/
    
          remaining--;
    
          /***********************************************************************
          *                                                                      *
          *  Set the phrase length to account for the unmatched symbol.          *
          *                                                                      *
          ***********************************************************************/
    
          length = 1;
    
       }
    
       /**************************************************************************
       *                                                                         *
       *  Copy the look-ahead buffer into the sliding window.                    *
       *                                                                         *
       **************************************************************************/
    
       memmove(&window[0], &window[length], LZ77_WINDOW_SIZE - length);
       memmove(&window[LZ77_WINDOW_SIZE - length], &buffer[0], length);
    
    }
    
    /*****************************************************************************
    *                                                                            *
    *  Point to the buffer of original data.                                     *
    *                                                                            *
    *****************************************************************************/
    
    *original = orig;
    
    /*****************************************************************************
    *                                                                            *
    *  Return the number of bytes in the original data.                          *
    *                                                                            *
    *****************************************************************************/
    
    return opos;
    
    }

  2. #2
    Registered User
    Join Date
    May 2012
    Posts
    1,066
    Quote Originally Posted by thames View Post
    I'm reading a code for LZ77 compression but htonl and other network functions can't be recognized (I get that unresolved identifier problem)
    Instead of posting 600+ lines of probably working code it would make more sense to post how you are trying to compile it and the exact error messages (don't paraphrase, copy'n'paste them!)

    Does this small snippet compile?
    Code:
    #include <arpa/inet.h>
     
    int main(void)
    {
        uint32_t test = 12345;
        uint32_t result = htonl(test);
        return 0;
    }
    Bye, Andreas

  3. #3
    Registered User
    Join Date
    Mar 2011
    Posts
    546
    are you getting a compiler error or a linker error?

  4. #4
    Tears of the stars thames's Avatar
    Join Date
    Oct 2012
    Location
    Rio, Brazil
    Posts
    193
    Instead of posting 600+ lines of probably working code it would make more sense to post how you are trying to compile it and the exact error messages (don't paraphrase, copy'n'paste them!)
    sorry for that. The snippet compiled and ran successfully.

    The output should be "compressing..." uncompressing..." instead, I don't get any errors.

    Code:
    gcc -g -Wall *.c
    thames@semath ~/NetBeansProjects/Compress $ valgrind ./a.out
    ==5477== Memcheck, a memory error detector
    ==5477== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
    ==5477== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
    ==5477== Command: ./a.out
    ==5477== 
    ==5477== 
    ==5477== HEAP SUMMARY:
    ==5477==     in use at exit: 0 bytes in 0 blocks
    ==5477==   total heap usage: 1 allocs, 1 frees, 568 bytes allocated
    ==5477== 
    ==5477== All heap blocks were freed -- no leaks are possible
    ==5477== 
    ==5477== For counts of detected and suppressed errors, rerun with: -v
    ==5477== ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 2 from 2)
    Last edited by thames; 01-22-2013 at 12:32 PM.

  5. #5
    Registered User
    Join Date
    May 2012
    Posts
    1,066
    Quote Originally Posted by thames View Post
    The snippet compiled and ran successfully.
    So you don't have a problem including <arpa/inet.h>

    Quote Originally Posted by thames View Post
    The output should be "compressing..." uncompressing..." instead, I don't get any errors.
    What output? Were you able to compile your program (no more errors about unresolved identifiers)?

    Bye, Andreas

  6. #6
    Tears of the stars thames's Avatar
    Join Date
    Oct 2012
    Location
    Rio, Brazil
    Posts
    193
    Code:
     
    Were you able to compile your program (no more errors about unresolved identifiers)?
    yes... the problem hasn't appeared when I compiled the program. The IDE (Netbeans) was pointing htonl couldn't be resolved (like if netinet/in.h hadn't been declared). Thus, the program is broken:

    Code:
    thames@semath ~/NetBeansProjects/Compression $ gcc -g -Wall *.c
    thames@semath ~/NetBeansProjects/Compression $ valgrind ./a.out
    ==3970== Memcheck, a memory error detector
    ==3970== Copyright (C) 2002-2011, and GNU GPL'd, by Julian Seward et al.
    ==3970== Using Valgrind-3.7.0 and LibVEX; rerun with -h for copyright info
    ==3970== Command: ./a.out
    ==3970== 
    Compressing with Huffman coding
    Compressing...Done
    Uncompressing...Done
    osize=5776, csize=3115, rsize=5776
    Data was restored OK
    Compressing with LZ77
    Compressing...Done
    ==3970== Conditional jump or move depends on uninitialised value(s)
    ==3970==    at 0x40310B: lz77_uncompress (lz77.c:427)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970== 
    ==3970== Conditional jump or move depends on uninitialised value(s)
    ==3970==    at 0x400A88: bit_set (bit.c:73)
    ==3970==    by 0x403165: lz77_uncompress (lz77.c:440)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970== 
    ==3970== Invalid read of size 1
    ==3970==    at 0x400A3A: bit_get (bit.c:40)
    ==3970==    by 0x40314C: lz77_uncompress (lz77.c:440)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970==  Address 0x5478941 is 0 bytes after a block of size 1,505 alloc'd
    ==3970==    at 0x4C2B4F0: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3970==    by 0x402E31: lz77_compress (lz77.c:277)
    ==3970==    by 0x4015A0: main (compressapp.c:145)
    ==3970== 
    ==3970== Invalid read of size 1
    ==3970==    at 0x400A3A: bit_get (bit.c:40)
    ==3970==    by 0x4031B8: lz77_uncompress (lz77.c:450)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970==  Address 0x5478942 is 1 bytes after a block of size 1,505 alloc'd
    ==3970==    at 0x4C2B4F0: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3970==    by 0x402E31: lz77_compress (lz77.c:277)
    ==3970==    by 0x4015A0: main (compressapp.c:145)
    ==3970== 
    ==3970== Invalid read of size 1
    ==3970==    at 0x400A3A: bit_get (bit.c:40)
    ==3970==    by 0x40321E: lz77_uncompress (lz77.c:460)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970==  Address 0x5478943 is 2 bytes after a block of size 1,505 alloc'd
    ==3970==    at 0x4C2B4F0: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3970==    by 0x402E31: lz77_compress (lz77.c:277)
    ==3970==    by 0x4015A0: main (compressapp.c:145)
    ==3970== 
    ==3970== Invalid read of size 1
    ==3970==    at 0x400A3A: bit_get (bit.c:40)
    ==3970==    by 0x4030F6: lz77_uncompress (lz77.c:424)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970==  Address 0x5478944 is 3 bytes after a block of size 1,505 alloc'd
    ==3970==    at 0x4C2B4F0: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3970==    by 0x402E31: lz77_compress (lz77.c:277)
    ==3970==    by 0x4015A0: main (compressapp.c:145)
    ==3970== 
    ==3970== Invalid read of size 1
    ==3970==    at 0x400A3A: bit_get (bit.c:40)
    ==3970==    by 0x403432: lz77_uncompress (lz77.c:582)
    ==3970==    by 0x40160E: main (compressapp.c:151)
    ==3970==  Address 0x5478944 is 3 bytes after a block of size 1,505 alloc'd
    ==3970==    at 0x4C2B4F0: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so)
    ==3970==    by 0x402E31: lz77_compress (lz77.c:277)
    ==3970==    by 0x4015A0: main (compressapp.c:145)
    ==3970== 
    Uncompressing...Done
    osize=5776, csize=1505, rsize=5776
    Data was not properly restored
    original[0]="/"
    restored[0]=0x00
    ==3970== 
    ==3970== HEAP SUMMARY:
    ==3970==     in use at exit: 0 bytes in 0 blocks
    ==3970==   total heap usage: 14,099 allocs, 14,099 frees, 28,319,609 bytes allocated
    ==3970== 
    ==3970== All heap blocks were freed -- no leaks are possible
    ==3970== 
    ==3970== For counts of detected and suppressed errors, rerun with: -v
    ==3970== Use --track-origins=yes to see where uninitialised values come from
    ==3970== ERROR SUMMARY: 14453 errors from 7 contexts (suppressed: 2 from 2)
    Magically, I don't know, the functions from netinet are being recognized.

    I encoded the sources and headers into a zip file.
    Attached Files Attached Files

Popular pages Recent additions subscribe to a feed

Similar Threads

  1. inet.h
    By aynzoya in forum C Programming
    Replies: 5
    Last Post: 02-06-2009, 08:51 PM
  2. htonl() vs ntohl()?
    By cpjust in forum C Programming
    Replies: 10
    Last Post: 11-11-2007, 11:26 PM
  3. INET Socket
    By Jornpje in forum C Programming
    Replies: 1
    Last Post: 04-19-2007, 05:34 AM
  4. Connection User via INet
    By Zeusbwr in forum C++ Programming
    Replies: 1
    Last Post: 10-09-2004, 02:47 AM
  5. inet map
    By iain in forum A Brief History of Cprogramming.com
    Replies: 0
    Last Post: 09-19-2001, 11:58 AM

Tags for this Thread


1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21