Кто глючит: SOCKET или Программер?

Вот мой сервак:

................
SOCKET    s,s_acc;
sockaddr_in sin,sin_acc;
................
s = socket (AF_INET, SOCK_STREAM, 0);
sin.sin_family = AF_INET;
sin.sin_addr.s_addr = INADDR_ANY;
sin.sin_port = SRV_PORT;
bind (s, (sockaddr *)&sin, sizeof(sin));
listen (s, MAX_CLIENT);
while (1)
{
        int len = sizeof(sockaddr_in);
        s_acc = accept (s, (sockaddr*)&sin_acc, &len);
        recv(s_acc,buffer,sizeof(buffer),0);
        shutdown (s_new, 0);
        close (s_new);
};

Всё как в стандартных примерах....
                               
                                       НО !!!!!!!!!!!!!!!!!!!!

....... я не могу никаким клиентом подключиться второй раз. Выдаёт эрор 10048 "Address already in use", типа он испльзуеться.

HELP !!!!!!!!!!!!
С меня пиво.

int opt = 1;
setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &opt, 4);

тебе поможет.

Зачем ты в цикле делаешь ШУТДАУН и клозесокет!!!!!!!! Ты не только закрывакшь сокет, но и шутдаеном закрываешь весю  среду. Вот тебе код, который не глючит!!! Просто вставь его в консольный проект. Будь здоров!!!!
PS Шутдаун можно вообще не делать.



#include <winsock2.h>

#include <stdio.h>
#include <stdlib.h>

#define DEFAULT_PORT        5150
#define DEFAULT_BUFFER      4096

int    iPort      = DEFAULT_PORT; // Port to listen for clients on
BOOL   bInterface = FALSE,       // Listen on the specified interface
      bRecvOnly  = FALSE;   // Receive data only; don't echo back
char   szAddress[128];       // Interface to listen for clients on

// Function: ClientThread
//
// Description:
//    This function is called as a thread, and it handles a given
//    client connection.  The parameter passed in is the socket
//    handle returned from an accept() call.  This function reads
//    data from the client and writes it back.
//
DWORD WINAPI ClientThread(LPVOID lpParam)
{
   SOCKET        sock=(SOCKET)lpParam;
   char          szBuff[DEFAULT_BUFFER];
   int           ret,
                 nLeft,
                 idx;

   while(1)
   {
       // Perform a blocking recv() call
       //
       ret = recv(sock, szBuff, DEFAULT_BUFFER, 0);
       if (ret == 0)        // Graceful close
           break;
       else if (ret == SOCKET_ERROR)
       {
           printf("recv() failed: \%d\n", WSAGetLastError());
           break;
       }
       szBuff[ret] = '\0';
       printf("RECV: '\%s'\n", szBuff);
       //
       // If we selected to echo the data back, do it
       //
       if (!bRecvOnly)
       {
           nLeft = ret;
           idx = 0;
                 //
           // Make sure we write all the data
           //
           while(nLeft > 0)
           {
               ret = send(sock, &szBuff[idx], nLeft, 0);
               if (ret == 0)
                   break;
               else if (ret == SOCKET_ERROR)
               {
                   printf("send() failed: \%d\n",
                       WSAGetLastError());
                   break;
               }
               nLeft -= ret;
               idx += ret;
              }
       }
   }
   return 0;
}

//
// Function: main
//
// Description:
//    Main thread of execution. Initialize Winsock, parse the
//    command line arguments, create the listening socket, bind
//    to the local address, and wait for client connections.
//
int main(int argc, char **argv)
{
   WSADATA       wsd;
   SOCKET        sListen,
                 sClient;
   int           iPort, iAddrSize;
   HANDLE        hThread;
   DWORD         dwThreadId;
   struct sockaddr_in local,
                      client;

//    ValidateArgs(argc, argv);
   if (WSAStartup(MAKEWORD(2,2), &wsd) != 0)
   {
       printf("Failed to load Winsock!\n");
       return 1;
   }
   // Create our listening socket
   //
   sListen = socket(AF_INET, SOCK_STREAM, IPPROTO_IP/*IPPROTO_TCP*/);
   if (sListen == SOCKET_ERROR)
   {
       printf("socket() failed: \%d\n", WSAGetLastError());
       return 1;
   }

     iPort = 25;
   local.sin_addr.s_addr = htonl(INADDR_ANY);
   local.sin_family = AF_INET;
   local.sin_port = htons(iPort);

   if (bind(sListen, (struct sockaddr *)&local,
           sizeof(local)) == SOCKET_ERROR)
   {
       printf("bind() failed: \%d\n", WSAGetLastError());
       return 1;
   }
   listen(sListen, 8);
   //
   // In a continous loop, wait for incoming clients. Once one
   // is detected, create a thread and pass the handle off to it.
   //
   while (1)
   {
       iAddrSize = sizeof(client);
       sClient = accept(sListen, (struct sockaddr *)&client,
                       &iAddrSize);        
       if (sClient == INVALID_SOCKET)
       {        
           printf("accept() failed: \%d\n", WSAGetLastError());
           break;
       }
       printf("Accepted client: \%s:\%d\n",
           inet_ntoa(client.sin_addr), ntohs(client.sin_port));

       hThread = CreateThread(NULL, 0, ClientThread,
                   (LPVOID)sClient, 0, &dwThreadId);
       if (hThread == NULL)
       {
           printf("CreateThread() failed: \%d\n", GetLastError());
           break;
       }
       CloseHandle(hThread);
   }
   closesocket(sListen);
   
   WSACleanup();
   return 0;
}

Да shutdown (s_new, 0) и close (s_new) здесь лишнее. И не забывай делать так:

memset(sin,0x0,sizeof(sin));<br>memset(sin_acc,0x0,sizeof(sin_acc));