/*
 * Basic system type definitions, taken from the BSD file sys/types.h.
 */
typedef unsigned char   u_char;
typedef unsigned short  u_short;
typedef unsigned int    u_int;
typedef unsigned long   u_long;

/*
 * The new type to be used in all
 * instances which refer to sockets.
 */
typedef u_int           SOCKET;

/*
 * Select uses arrays of SOCKETs.  These macros manipulate such
 * arrays.  FD_SETSIZE may be defined by the user before including
 * this file, but the default here should be >= 64.
 *
 * CAVEAT IMPLEMENTOR and USER: THESE MACROS AND TYPES MUST BE
 * INCLUDED IN WINSOCK.H EXACTLY AS SHOWN HERE.
 */
#ifndef FD_SETSIZE
#define FD_SETSIZE      64
#endif /* FD_SETSIZE */

typedef struct fd_set {
        u_int   fd_count;               /* how many are SET? */
        SOCKET  fd_array[FD_SETSIZE];   /* an array of SOCKETs */
} fd_set;

#ifdef __cplusplus
extern "C" {
#endif

extern int PASCAL FAR __WSAFDIsSet(SOCKET, fd_set FAR *);

#ifdef __cplusplus
}
#endif


#define FD_CLR(fd, set) do { \
    u_int __i; \
    for (__i = 0; __i < ((fd_set FAR *)(set))->fd_count ; __i++) { \
        if (((fd_set FAR *)(set))->fd_array[__i] == fd) { \
            while (__i < ((fd_set FAR *)(set))->fd_count-1) { \
                ((fd_set FAR *)(set))->fd_array[__i] = \
                    ((fd_set FAR *)(set))->fd_array[__i+1]; \
                __i++; \
            } \
            ((fd_set FAR *)(set))->fd_count--; \
            break; \
        } \
    } \
} while(0)

#define FD_SET(fd, set) do { \
    if (((fd_set FAR *)(set))->fd_count < FD_SETSIZE) \
        ((fd_set FAR *)(set))->fd_array[((fd_set FAR *)(set))->fd_count++]=(fd);\
} while(0)

#define FD_ZERO(set) (((fd_set FAR *)(set))->fd_count=0)

#define FD_ISSET(fd, set) __WSAFDIsSet((SOCKET)(fd), (fd_set FAR *)(set))    

12. Conclusion

Now you've seen both a blocking client and a blocking server. Blocking sockets are relatively easy to use because they fit in nicely in the program flow. Still, you've only seen pretty simple examples, since both the client and the server we showed did practically nothing with the data other than print it or in this case, encrypt and then send it back. It gets harder when we have to extract meaningful information from the received data like when dealing with a protocol like POP3. This is the point where most beginners get stuck. The next chapters will tell you more on how to deal with this.

;fd_set macros
FD_SETSIZE = 64

struct fd_set
  fd_count      dd ?
  fd_array      dd FD_SETSIZE dup (?)
ends

;helper macros
macro FD_CLR fd, set
{ push  set
  push  fd
  call  pFD_CLR
}

macro FD_SET fd, set
{ push  set
  push  fd
  call  pFD_SET
}

macro FD_ZERO set
{ push  set
  call  pFD_ZERO
}

macro FD_ISSET fd, set
{ push  set
  push  fd
  call  pFD_ISSET
}

;fd_set functions
proc pFD_CLR  fd, set
  push  esi
  push  ecx
  push  ebx
  mov   ebx, [set]
  mov   esi, [fd]
  xor   ecx, ecx
 .oloop:
  cmp   ecx, [ebx+fd_set.fd_count]
  jge   .cleanup
  cmp   esi, [ebx+ecx*4+fd_set.fd_array]
  jz    .iloop
  inc   ecx
  jmp   .oloop
 .iloop:
  mov   eax, [ebx+ecx*4+fd_set.fd_array+4]
  mov   [ebx+ecx*4+fd_set.fd_array], eax
  inc   ecx
  cmp   ecx, [ebx+fd_set.fd_count]
  jl    .iloop
  dec   [ebx+fd_set.fd_count]
 .cleanup:
  pop   ebx
  pop   ecx
  pop   esi
  ret
endp

proc pFD_SET fd, set
  push  ebx
  mov   ebx, [set]
  mov   eax, [ebx+fd_set.fd_count]
  cmp   eax, FD_SETSIZE
  jge   .cleanup
  push  [fd]
  pop   [eax*4+ebx+fd_set.fd_array]
  inc   [ebx+fd_set.fd_count]
 .cleanup:
  pop   ebx
  ret
endp

proc pFD_ZERO set
  mov   eax, [set]
  mov   [eax+fd_set.fd_count], 0
  ret
endp

proc pFD_ISSET fd, set
  push  esi
  push  ecx
  push  ebx
  mov   ebx, [set]
  mov   esi, [fd]
  xor   ecx, ecx
  xor   eax, eax
 .oloop:
  cmp   ecx, [ebx+fd_set.fd_count]
  jge   .cleanup
  cmp   esi, [ebx+ecx*4+fd_set.fd_array]
  jz    .found
  inc   ecx
  jmp   .oloop
 .found:
  inc   eax
 .cleanup:
  pop   ebx
  pop   ecx
  pop   esi
  ret
endp