System action: (시스템에서는 그럼 어케 하느냐...??)

The client will try to reestablish a connection with the server. (클라이언트는 서버와의 접속을 재시도 할것이외다.)
If the TSM server administrator cancelled the session, then the attempt to reestablish the connection
will fail and message ANS1369E will be issued.
(만약에 TSM 서버 어드민이 클라이언트 세션을 취소하였다면, 이러한 실패 메세지를 던져주고-ANS1809W-재접속을 할 거다.)

If the attempt to reestablish the connection is successful, then processing will continue.
( 재접속 시도가 성공되면 프로세싱이 계속 될 것이외다.)

If the attempt to reestablish the connection fails, then the client will continue to try to reestablish
a connection according to the COMMRESTARTDURATION and COMMRESTARTINTERVAL client option settings.
(그럼에도 불구하고 재접속 시도가 실패한다면 클라이언트는 옵션세팅인
COMMRESTARTDURATION{커맨드리스타트듀레이션?의 약자인듯???}
과
COMMRESTARTINTERVAL{커맨드리스타트 인터발??}
에 따라서 착하게 계속 시도할 것이란다.)

User response:  ( 뭐가 문제인지 알고싶으시다면)
If the session was cancelled by the TSM server administrator and you do not know why, or
if the client is unable to reestablish a session with the TSM server, then contact your TSM server administrator for further information.
(세션이 TSM서버에 의해 취소되는것은 왜그런지 알수 없거나 클라이언트가 계속 TSM 에 접속할 수 없다면 뭣 좀 알기위해 TSM 서버 어드민에 접근해보아야 한다.)

Frequent occurrences of the ANS1809W message can indicate a problem with the network.
(빈번한 이 메세지의 출현은 네트워크의 문제라는것을 지적할수있단다.)

If this message is repeatedly found in the dsmerror.log,
investigate possible networking trouble, such as a failing network interface card or router problem.
(---dsmerror.log에서 이메세지가 반복적으로 나타나면, 네트워크 트러블을 마니조사해봐라 네트워크 인터페이스카드나 머 라우터라든지... --근데 dsmerror.log로그에서 난 나오는게 없던데..다른 로그만 나오고...;;;)

One common problem is the media speed of the network adaptors:
(가장 흔한 문제는 네트워크 어뎁터의 미디어스피드 이다.)
If the network adaptors are set to "auto-negotiate", try changing them to "100%% full duplex".
네트워크 어댑터 가 '오토 네고시에이트' 로 되어있으면 '100프로 풀 듀플렉스'로 바꾸어보자
--> 이게 말이 쉽지 회사에서 쓰는건데 함부로 바꾸면...소심하자나..;;;

If the problem persists, then as a temporary measure ask your TSM server administrator increase the
COMMTIMEOUT and IDLETIMEOUT option settings on the TSM server. This might reduce the frequency of this message.
(그럼에도 불구하고 문제가 계속되면 '코멘드타임아웃'이나 '아이들타임아웃'세팅을 늘려보아라 TSM 에 있단다.
메세지 빈도수를 줄여준단다.



*** 자주 나타나는 증상은 아니지만 백업시에, 2주에 한번꼴로는 나타나는 거라서 참 거슬린다.***

tsm: YPEDB> q vol //상태를 확인한다.

Volume Name                  Storage         Device         Estimated       Pct      Volume
                             Pool Name       Class Name      Capacity      Util      Status
------------------------     -----------     ----------     ---------     -----     --------
/TSMDATA2/DATA01.DSM         IMSIPOOL        DISK             512.0 G       0.0     On-Line
F10049L4                     ORACOLD_09-     3100CLASS          0.0 M       0.0      Empty 
                              01                                                           
F10050L4                     ORACOLD_08-     3100CLASS          1.6 T      35.9     Filling
                              12                                                           
F10051L4                     YPE_YEAR        3100CLASS          1.6 T      19.5     Filling
F10052L4                     IFC_YEAR        3100CLASS          1.6 T      39.2     Filling
F10058L4                     IFC_SO          3100CLASS          1.6 T      19.6     Filling
F10060L4                     YPE_DA          3100CLASS          1.6 T       0.0     Filling
F10061L4                     YPE_DA          3100CLASS          2.2 T      95.2     Filling
F10062L4                     YPE_DA          3100CLASS          4.1 T       6.6       Full 
F10063L4                     YPE_DA          3100CLASS          0.0 M       0.0      Empty 
F10064L4                     YPE_DA          3100CLASS          0.0 M       0.0      Empty 
F10065L4                     YPE_DA          3100CLASS          4.0 T       1.8       Full 
F10066L4                     YPE_DA          3100CLASS          1.6 T       0.0     Filling
F10067L4                     YPE_SO          3100CLASS          4.6 T      27.2       Full 
F10068L4                     YPE_SO          3100CLASS          3.1 T      55.5     Filling
F10069L4                     YPE_SO          3100CLASS          1.6 T      26.8     Filling
F10070L4                     IFC_DA          3100CLASS          3.6 T      15.5       Full 
F10071L4                     IFC_DA          3100CLASS          1.6 T      18.1     Filling
F10072L4                     IFC_DA          3100CLASS          1.6 T      12.9     Filling
F10073L4                     IFC_DA          3100CLASS          1.6 T       4.3     Filling
F10074L4                     IFC_DA          3100CLASS          3.5 T      32.5       Full 
F10075L4                     IFC_DA          3100CLASS          0.0 M       0.0      Empty 
F10076L4                     IFC_DA          3100CLASS          3.5 T      92.7       Full 
F10077L4                     IFC_SO          3100CLASS          3.5 T      83.2       Full 
F10078L4                     IFC_SO          3100CLASS          3.7 T      61.5       Full 
F10079L4                     IFC_SO          3100CLASS          3.6 T      38.6       Full 

tsm: YPEDB>q stgpo imsipool f=d //임시풀의 상태를 확인하고 next 의 위치를 옮긴다.

               Storage Pool Name: IMSIPOOL
               Storage Pool Type: Primary
               Device Class Name: DISK
              Estimated Capacity: 512 G
              Space Trigger Util: 0.0
                        Pct Util: 0.0
                        Pct Migr: 0.0
                     Pct Logical: 100.0
                    High Mig Pct: 0
                     Low Mig Pct: 0
                 Migration Delay: 0
              Migration Continue: Yes
             Migration Processes: 1
           Reclamation Processes:
               Next Storage Pool: YPE_DA //현재는 YPE_DA 이므로 ifc_so 로 바꾸어준다.
            Reclaim Storage Pool:
          Maximum Size Threshold: No Limit
                          Access: Read/Write
                     Description:
               Overflow Location:
           Cache Migrated Files?: No
                      Collocate?:
           Reclamation Threshold:
       Offsite Reclamation Limit:
 Maximum Scratch Volumes Allowed:
  Number of Scratch Volumes Used:
   Delay Period for Volume Reuse:
          Migration in Progress?: No
            Amount Migrated (MB): 13,565.88
Elapsed Migration Time (seconds): 202
        Reclamation in Progress?:
  Last Update by (administrator): ADMIN
           Last Update Date/Time: 07/07/09   09:20:58
        Storage Pool Data Format: Native
            Copy Storage Pool(s):
             Active Data Pool(s):
         Continue Copy on Error?: Yes
                        CRC Data: No
more...   (<ENTER> to continue, 'C' to cancel)

                Reclamation Type:
     Overwrite Data when Deleted:

tsm: YPEDB>

tsm: YPEDB>update stgpo imsipool next=ifc_so

ANR2202I Storage pool IMSIPOOL updated. //이런 메시제가 뜨면서 업데이트가 완료되었음을 알려준다.

tsm: YPEDB>q stgpo imsipool f=d //다시한번 next에 주의하면서 보면

Storage Pool Name: IMSIPOOL
               Storage Pool Type: Primary
               Device Class Name: DISK
              Estimated Capacity: 512 G
              Space Trigger Util: 0.0
                        Pct Util: 0.0
                        Pct Migr: 0.0
                     Pct Logical: 100.0
                    High Mig Pct: 0
                     Low Mig Pct: 0
                 Migration Delay: 0
              Migration Continue: Yes
             Migration Processes: 1
           Reclamation Processes:
               Next Storage Pool: IFC_SO   //바뀌어있다.
            Reclaim Storage Pool:
          Maximum Size Threshold: No Limit
                          Access: Read/Write
                     Description:
               Overflow Location:
           Cache Migrated Files?: No
                      Collocate?:
           Reclamation Threshold:
       Offsite Reclamation Limit:
 Maximum Scratch Volumes Allowed:
  Number of Scratch Volumes Used:
   Delay Period for Volume Reuse:
          Migration in Progress?: No
            Amount Migrated (MB): 13,565.88
Elapsed Migration Time (seconds): 202
        Reclamation in Progress?:
  Last Update by (administrator): ADMIN
           Last Update Date/Time: 07/20/09   13:20:44
        Storage Pool Data Format: Native
            Copy Storage Pool(s):
             Active Data Pool(s):
         Continue Copy on Error?: Yes
                        CRC Data: No
more...   (<ENTER> to continue, 'C' to cancel)

                Reclamation Type:
     Overwrite Data when Deleted:

tsm: YPEDB>move data f10079l4 stgpo=imsipool //79번에 있는 데이터를 옮긴다.

ANR2233W This command will move all of the data stored on volume F10079L4 to other volumes in storage
pool IMSIPOOL; the data will be inaccessible to users until the operation completes.

Do you wish to proceed? (Yes (Y)/No (N)) y  //yes 를 선택하고 q pro로 상태를 확인한다.
ANS8003I Process number 354 started.

tsm: YPEDB>q pro

 Process     Process Description      Status                                          
  Number                             
--------     --------------------     -------------------------------------------------
     354     Move Data                Volume F10079L4 (storage pool IFC_SO), Target   
                                       Pool IMSIPOOL, Moved Files: 0, Moved Bytes: 0, 
                                       Unreadable Files: 0, Unreadable Bytes: 0.      
                                       Current Physical File (bytes): 12,584,457,039  
                                       Waiting for mount of input volume F10079L4 (2  
                                       seconds).    

전부 끝났으면  임시풀에 있는 데이터를 넥스트인 IFC_SO 로 보내야 한다.
하지만 그 전에 임시풀에서 내리면 넥스트인 IFC_SO가 도로 그 데이터를 받을 수 있으므로
IFC_SO를 리드온니 상태로 바꾸어 줘야 한다.

tsm: YPEDB>update vol f10058l4 acc=readonly //이렇게 한다.

그리고 나서 임시풀을 내려주는데 내린다는 말의 뜻은 hi스택을 100d에서 0으로 내려야 한다.

내리기 전에 hi스택이 어떤값을 가지고 있는지 볼 필요가 있다.

tsm: YPEDB>q stgpo imsipool f=d //이렇게 치면
 Storage Pool Name: IMSIPOOL
               Storage Pool Type: Primary
               Device Class Name: DISK
              Estimated Capacity: 512 G
              Space Trigger Util: 99.9
                        Pct Util: 99.9
                        Pct Migr: 99.9
                     Pct Logical: 100.0 
                    High Mig Pct: 100   //100이다 여기를 살필것
                     Low Mig Pct: 0
                 Migration Delay: 0
              Migration Continue: Yes
             Migration Processes: 1
           Reclamation Processes:
               Next Storage Pool: IFC_SO
            Reclaim Storage Pool:
          Maximum Size Threshold: No Limit
                          Access: Read/Write
                     Description:
               Overflow Location:
           Cache Migrated Files?: No
                      Collocate?:
           Reclamation Threshold:
       Offsite Reclamation Limit:
 Maximum Scratch Volumes Allowed:
  Number of Scratch Volumes Used:
   Delay Period for Volume Reuse:
          Migration in Progress?: Yes
            Amount Migrated (MB): 0.00
Elapsed Migration Time (seconds): 742
        Reclamation in Progress?:
  Last Update by (administrator): ADMIN
           Last Update Date/Time: 07/22/2009 19:15:03
        Storage Pool Data Format: Native
            Copy Storage Pool(s):
             Active Data Pool(s):
         Continue Copy on Error?: Yes
                        CRC Data: No
                Reclamation Type:
     Overwrite Data when Deleted:

 이렇게 나온다. 그리고 나서 100을 확인한 후 내린다.

 이때에는

tsm: YPEDB>update stgpo imsipool hi=0     // 이렇게 쳐넣으면 된다.
ANR2202I Storage pool IMSIPOOL updated.

q vol을 쳐봐서 임시풀이 0 이 되면 다시 100을 올려준다.

tsm: YPEDB>q vol
 
Volume Name                  Storage         Device         Estimated       Pct      Volume
                             Pool Name       Class Name      Capacity      Util      Status
------------------------     -----------     ----------     ---------     -----     --------
/TSMDATA2/DATA01.DSM         IMSIPOOL        DISK             512.0 G       0.0     On-Line 
/TSMDATA2/reclaim/00000-     RECLPOOL        FILEDEV          102.4 G      11.4     Filling
 455.BFS                                                                                   
/TSMDATA2/reclaim/00000-     RECLPOOL        FILEDEV          102.4 G      81.7     Filling
 456.BFS                                                                                   
/TSMDATA2/reclaim/00000-     RECLPOOL        FILEDEV          102.4 G      36.1     Filling
 457.BFS                                                                                   
/TSMDATA2/reclaim/00000-     RECLPOOL        FILEDEV          102.4 G       0.0     Filling
 458.BFS                                                                                   
/TSMDATA2/reclaim/00000-     RECLPOOL        FILEDEV          102.4 G       0.0     Filling
 459.BFS                                                                                   
F10049L4                     ORACOLD_09-     3100CLASS          0.0 M       0.0      Empty 
                              01                                                           
F10050L4                     ORACOLD_08-     3100CLASS          1.6 T      35.9     Filling
                              12                                                           
F10051L4                     YPE_YEAR        3100CLASS          1.6 T      19.5     Filling
F10052L4                     IFC_YEAR        3100CLASS          1.6 T      39.2     Filling
F10058L4                     IFC_SO          3100CLASS          1.7 T      70.2     Filling //이걸 다 빼준다.
F10060L4                     YPE_DA          3100CLASS          1.6 T       0.0     Filling
F10061L4                     YPE_DA          3100CLASS          2.9 T      69.8     Filling
F10062L4                     YPE_DA          3100CLASS          4.1 T       6.6       Full 
F10063L4                     YPE_DA          3100CLASS          0.0 M       0.0      Empty 
F10064L4                     YPE_DA          3100CLASS          0.0 M       0.0      Empty 
F10065L4                     YPE_DA          3100CLASS          4.0 T       1.3       Full 
F10066L4                     YPE_DA          3100CLASS          1.6 T       0.0     Filling
F10067L4                     YPE_SO          3100CLASS          4.6 T      27.2       Full 
F10068L4                     YPE_SO          3100CLASS          3.1 T      55.2     Filling
F10069L4                     YPE_SO          3100CLASS          1.6 T      26.8     Filling
F10070L4                     IFC_DA          3100CLASS          3.6 T      15.5       Full 
F10071L4                     IFC_DA          3100CLASS          2.1 T      88.5     Filling
F10072L4                     IFC_DA          3100CLASS          1.6 T      12.9     Filling
F10073L4                     IFC_DA          3100CLASS          1.6 T       1.1     Filling
F10074L4                     IFC_DA          3100CLASS          0.0 M       0.0      Empty 
F10075L4                     IFC_DA          3100CLASS          0.0 M       0.0      Empty 
F10076L4                     IFC_DA          3100CLASS          3.5 T      76.9       Full 
F10077L4                     IFC_SO          3100CLASS          3.5 T      83.1       Full 
F10078L4                     IFC_SO          3100CLASS          3.7 T      61.5       Full 
F10079L4                     IFC_SO          3100CLASS          1.6 T      32.0     Filling
 

위의 IFC_SO가 0이 이 될때까지 imsipool의 hi값을 0으로 내려준다.

tsm: YPEDB>update stgpo imsipool hi=0
ANR2202I Storage pool IMSIPOOL updated.

imsipool값이 0이 되면 100으로 올린뒤에 도로 58번의 값을 imsipool로 옮겨준다.

tsm: YPEDB>update stgpo imsipool hi=100  //올리고

tsm: YPEDB>move data  f10058l4=imsipool //옮겨준다.

tsm: YPEDB>q volh type=dbbackup /// tsm 중에 모두가 private 가되어 어느쪽을 빼야할지 모를때 이렇게
치고 가장 마지막에 access 된놈을 빼야한다. ///

       Date/Time: 07/19/09   09:05:39
     Volume Type: BACKUPFULL
   Backup Series: 178
Backup Operation: 0
      Volume Seq: 1
    Device Class: 3100CLASS
     Volume Name: F10057L4
 Volume Location:
         Command:

       Date/Time: 07/20/09   09:02:37 //20일, 위에것보다 하루 빠르므로 59번을 빼주면 된다.
     Volume Type: BACKUPFULL
   Backup Series: 179
Backup Operation: 0
      Volume Seq: 1
    Device Class: 3100CLASS
     Volume Name: F10059L4
 Volume Location:
         Command:

#define MAXLINE  512
#define MAX_SOCK 64
#define PORT 3030
 
char *escapechar = "exit";
int getmax(int);
void removeClient(int);   /* 채팅 탈퇴 처리 함수 */
char* mid(char* str,int a,int b);

int  maxfdp1;               /* 최대 소켓번호 +1 */
int  num_chat = 0;          /* 채팅 참가자 수 */
//int client_s[MAX_SOCK];     /* 채팅에 참가자 소켓번호 목록 */

int main(int argc, char *argv[])  {
 char rline[MAXLINE], my_msg[MAXLINE];
 char *start = "Connected to chat_server YOU ARE NOW : Waiting_Room\n1.Room_List 2.Make_Room 3.Room_Enter 4.User_List (/h Help)\n Input>";
 int i, j, n;
 int s, client_fd, clilen;

 fd_set  read_fds;     /* 읽기를 감지할 소켓번호 구조체 */
 struct sockaddr_in  client_addr, server_addr;
   if(argc != 2)  {
      printf("사용법 :%s port\n", argv[0]);
      exit(0);
   }
 
   printf("\nServer Is Running NoW\n\n");
   /* 초기소켓 생성 */
 if((s = socket(PF_INET, SOCK_STREAM, 0)) < 0)  { 
  printf("Server: Can't open stream socket.");  
  exit(0);
 }
  
   /* server_addr 구조체의 내용 세팅 */
 bzero((char *)&server_addr, sizeof(server_addr)); 
 server_addr.sin_family = AF_INET;             
 server_addr.sin_addr.s_addr = htonl(INADDR_ANY);
 server_addr.sin_port = htons(atoi(argv[1]));    
  
 if (bind(s,(struct sockaddr *)&server_addr,sizeof(server_addr)) < 0) {
  printf("Server: Can't bind local address.\n");
  exit(0);
 }
   /* 클라이언트로부터 연결요청을 기다림 */
 listen(s, 5);

 maxfdp1 = s + 1;    /* 최대 소켓번호 +1 */

 while(1) {
    int temp_socketfd=0;

    for(i=0;i<MAXLINE;i++){
   rline[i]='\0';                //rline[] 초기화
  }

   FD_ZERO(&read_fds);
  FD_SET(s, &read_fds);
 
  for(i=0; i<num_chat; i++){ 
   temp_socketfd = get_user_socketfd(i);
   FD_SET(temp_socketfd,&read_fds);
  }
  maxfdp1 = getmax(s) + 1;     /* maxfdp1 재 계산 */
  if (select(maxfdp1, &read_fds, (fd_set *)0, (fd_set *)0,(struct timeval *)0) < 0) {
   printf("select error <= 0 \n");
   exit(0);
  }
  if(FD_ISSET(s, &read_fds)) {
   clilen = sizeof(client_addr);
   client_fd = accept(s, (struct sockaddr *)&client_addr, &clilen);
   
   
   
   
   char *ip= "127.0.0.1";
//   char *ip = inet_ntoa(client_addr.sin_addr);
//   int dsfsdf = inet_ntoa(client_addr.sin_addr.s_addr);
   printf("\n클라이언트 : %d \n",ip);
         if(client_fd == -1)  {
          printf("accept error\n");
          exit(0);
   }
       /* 채팅 클라이언트 목록에 추가 */
   
         num_chat++;
   recv(client_fd, rline, MAXLINE, 0);

         send(client_fd, start, strlen(start), 0);
   
   insert_user_node(client_fd,rline,ip);
         printf("%d번째 사용자 추가.(%s)\n", num_chat,rline);
   display();
  }
         
     /* 클라이언트가 보낸 메시지를 모든 클라이언트에게 방송 */
  
  for(i = 0; i < num_chat; i++)  {
   temp_socketfd = get_user_socketfd(i);
   int current_user_room = get_user_room(temp_socketfd); //현재 어느 방에 있는 사용자가 메시지를 보냈는지 체크한다.
       if(FD_ISSET(temp_socketfd, &read_fds)) {
    
           if((n = recv(temp_socketfd, rline, MAXLINE, 0))  <= 0)  {
     removeClient(i); /* abrupt exit */
     continue;
    } 
           /* 종료문자 처리 */
           if(strstr(rline, escapechar) != NULL) {
     removeClient(i); /* abrupt exit */
     continue;
   }
      /* 모든 채팅 참가자에게 메시지 방송 */
          rline[n] = '\0';

            
    // 쪽지//////////////////////////////////////////

    // 대기실, 대화방 어디에 있던지 위치에 상관없이 쪽지(1:1대화) 가능.
    // 대화방 간에 쪽지(1:1) 가능

    char *temp = strchr(rline,' ');
    temp++; //공백 없애기 위해
     
    
    if(temp[0]=='/'){ //쪽지 옵션          ' / ' <-- 이 문자로 시작하면 대화가 아닌 특정 기능 수행이므로 따로 처리한다
     char *option = mid(temp,1,3);    // 옵션부분을 파싱한다
     //printf("|%s|",option);
     char *id_message=strchr(temp,' ');
     id_message++;
     
     if(strcmp(option,"/to")==0){ //쪽지 /to 옵션일경우    ex) /to 닉네임 할말
      char *message = strchr(id_message,' '); //메시지를 파싱한다
      message++;
      char *id = mid(id_message,1,strcspn(id_message," ")); // 아이디를 파싱
      
      //printf("\nid-|%s|,message-|%s|\n",id,message);
      int message_socketfd = get_sockerfd_by_user_name(id);  //아이디로부터 소켓번호를 얻어온다

      //printf("\nsocket : %d\n",message_socketfd);
      if(message_socketfd==0){ //소켓번호가 0이면 사용자가 아이디를 잘못입력 한 것이므로 오류메시지 전송
       send(temp_socketfd, "\n존재하지 않는 사용자입니다.\n", strlen("\n존재하지 않는 사용자입니다.\n"), 0);
      }else{
       char t[1024] ;  //쪽지를 전달한다
       sprintf(t,"%s SEND YOU THIS MESSAGE : %s",get_user_name_by_socketfd(temp_socketfd),message);
       
       send(message_socketfd,t,strlen(t),0);
       continue;
       
      }
     }// /to 옵션
     else if(strcmp(option,"/tr")==0){ //파일 전송 명령

      //   ex)  클라이언트 A가 "/tr 대화명(client B) filename "
      //
      //        입력시 server에서 client B 로 "/tr IP Address(client A) filename"
      //        이 전송됨.(대화명이 IP Address로 변환되어 전송)
      //        client A는 "/reply transfer filename " 을 서버로 부터 받고 송신모드 전환
      //        이 때부터는 서버와 독립적으로 클라이언트 대 클라이언트 연결
      //        client B가 서버로 부터 받은 주소를 통해 client A에 접속. 파일 받음.

      char *filename=strchr(id_message,' '); //수신자가 받을 파일명
      char *id = mid(id_message,1,strcspn(id_message," ")); //수신자 아이디
      char message[50];
      filename++;
      filename[strlen(filename)-1]= '\0';
      char *sender_name = get_user_name_by_socketfd(temp_socketfd); //송신자의 소켓번호로부터 사용자의 닉네임 파악
      char *sender_ip = get_user_ip_by_socketfd(temp_socketfd); //송신자의 소켓번호로 송신자의 아이피 파악

      int message_socketfd = get_sockerfd_by_user_name(id);//사용자 아이디로부터 소켓번호를 얻어온다.
      if(message_socketfd==0){
       send(temp_socketfd,"\n없는 사용자 입니다.\n",strlen("\n없는 사용자 입니다.\n"),0);
       continue;
      }

      sprintf(message,"/reply transfer %s", filename); //송신자에게 보내는 메시지
              // 위의 메시지를 보내 사용자가 송신 작업을 수행하도록 한다.
      send(temp_socketfd,message,strlen(message),0);
      memset(&message, 0, sizeof(message));
      sprintf(message,"/tr %s %s",sender_ip, filename); //수신자에게 보내는 메시지
      send(message_socketfd,message,strlen(message),0); //송신자의 정보를 전달해 수신자가 송신자의 서버에 접속하는 작업을 수행
                                                                                     //할수 있도록 한다.
      continue; 
      
      
     }else if(temp[1]=='q'){  //대화방을 나가고자 할때 사용되는 명령
      int room = get_user_room(temp_socketfd);
      if(room==0){
       send(temp_socketfd,"\n현재 위치는 대기실 입니다.\n",strlen("\n현재 위치는 대기실 입니다.\n"),0);
       continue;
      }
       user_out_of_room(room,temp_socketfd); //대화방에서 대기실로 나가는 처리를 한다
       send(temp_socketfd,"\n대기실로 나갑니다.\n",strlen("\n대기실로 나갑니다.\n"),0);

     }else if(temp[1]=='h'){ //도움말
      char *m = "SMS : /to USER MESSAGE  (/to nonnous HI~)\nFILE TRASFER : /tr USER FILENAME (/tr nonnous readme.txt)\nOUT : /q\nEXIT : exit\n";
      send(temp_socketfd,m,strlen(m),0);
     }
    }
   

    if(get_user_room(temp_socketfd)==0){ //유저의 위치가 대화방일때는 메뉴를 선택하도록한다.

     char *temp = "1.Room_List 2.Make_Room 3.Room_Enter 4.User_List (/h Help)\n Input>";

     //char * strchr(char *s, int c)
     int select = atoi(strchr(rline,' '));

     if(select==1){  //사용자가 대화방에 들어가고자 할때
      if(get_room_num()==0){ //개설된 방이 없을때
       send(temp_socketfd,"\nThere is no Room To CREATE.\n\n",strlen("\nThere is no Room To CREATE\n\n"),0);
      }else{
       send(temp_socketfd, room_info(), strlen(room_info()), 0); //개설된 방이 있을땐 방 목록 정보를 제공
      }

     }else if(select==2){ //사용자가 방을 개설하기를 원할때
      char message[512];
      send(temp_socketfd, "\nTYPE ROOM NAME TO CREATE>", strlen("\nTYPE ROOM NAME TO CREATE>"), 0);
      int n = recv(temp_socketfd, rline, MAXLINE, 0);
      rline[n-1] = '\0';
      int room_num = insert_room_node(strchr(rline,' '));
      user_node *t_node = get_user_node_by_socketfd(temp_socketfd);
      t_node->room = room_num; //사용자의 소속 방 번호를 변경해준다
      sprintf(message,"\n%d YOU ARE ENTER THAT ROOM.\n ",room_num);
      send(temp_socketfd, message, strlen(message), 0);
      continue;

     }else if(select==3){ //사용자가  입장을 선택했을때.

      room_display();
      char message[512];

      send(temp_socketfd, "\nENTER THE ROOM NUMBER .\n", strlen("\nENTER THE ROOM NUMBER.\n"), 0);
      int n = recv(temp_socketfd, message, MAXLINE, 0);
      int num = atoi(strchr(message,' '));

      
      if(user_join_room(num,temp_socketfd)==0){
       send(temp_socketfd, "\nTHRER'S NO ROOM YOU CHOOSE.\n", strlen("\nTHRER'S NO ROOM YOU CHOOSE.\n"), 0);
      }else{
       sprintf(message,"\n%d YOU ARE ENTER THE ROOM.\n",num);
       send(temp_socketfd, message, strlen(message), 0);
      }
     }else if(select ==4){ //사용자가 사용자의 목록을 요청했을때
      
      user_node *temp = user_head;
      send(temp_socketfd, "\n-------USER LIST-----------\n", strlen("\n-------USER LIST-----------\n"), 0);
      char buff[55];
      int i=1;
      while(temp!=NULL){
   
       sprintf(buff,"%2d. %s(%s)\n",i++,temp->user_name,temp->user_ip);
       send(temp_socketfd, buff, strlen(buff), 0);
       temp = temp->next;
      }
      send(temp_socketfd, "\n-------USER LIST-----------\n", strlen("\n-------USER LIST-----------\n"), 0);
     }

    // printf("%d\n",select);
     send(temp_socketfd, temp, strlen(temp), 0);
     
    }else{ // 유저의 현재 위치가 대화방 내일 경우에

     for (j = 0; j < get_user_num(); j++){
      int temp_socketfd2 = get_user_socketfd(j);
      if(current_user_room ==get_user_room(temp_socketfd2)) //자신과 동일한 방에 있는 사용자에게만 메시지 출력
       send(temp_socketfd2, rline, n, 0);
      //printf("socket : %d\n",temp_socketfd2);
     }
     printf("%s", rline);
    }
   }
  }
 }    
}    

/* 채팅 탈퇴 처리 */
void removeClient(int i) {
 int temp_socketfd = get_user_socketfd(i);
 close(temp_socketfd);
//   if(i != num_chat-1) client_s[i] = client_s[num_chat-1];

 int room = get_user_room(temp_socketfd);
 if(room!=0&& user_out_of_room(room,0)==1){ //마지막 사용자일땐 방도 함께 삭제
  delete_room_node(room);
 }

 delete_user_node(temp_socketfd);
   num_chat--;
 printf("CHATTER 1 IS OUT NOW . NOW IN HERE = %d\n", num_chat);
}

/* clien_s[] 내의 최대 소켓번호 얻기(초기치는 k) */
int getmax(int k) {
 int max = k;   
 int r;
 for (r=0; r < num_chat; r++) {
    if (get_user_socketfd(r) > max ) max = get_user_socketfd(r);
 }
  return max;
}

클라이언트 측

#include <stdio.h>
#include <fcntl.h>
#include <stdlib.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <sys/time.h>
#include <string.h>
#include <pthread.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <pthread.h>
#include "myutil.h"
//#include "transfer.h"

#define MAXLINE 512
#define MAX_SOCK 128
#define port  7479
#define max 5
#define bufsize 1024
 
//void* recv_thread(void* ip,void* filename);

char *escapechar = "exit";
char name[10];       /* 채팅에서 사용할 이름 */

typedef union addr { 
 unsigned long int my_ip; 
 struct in_addr my_addr;     
}InetAddress;

void recv_thread(char *ip_filename){  // 클라이언트가 데이터를 받을 때 사용하는 함수
             //원래는 파일 수신도 스레드로 처리하려 했으나
 struct sockaddr_in saddr;         //쓰레드 사용하지 않아도 잘 수행되어 단순 호출 하였습니다.
  int sockfd;
  char buf[bufsize]={0,};
  int fd;
  int cnt;

  char *ip = mid(ip_filename,1,strcspn((char *)ip_filename," ")); //서버로 부터 전송받은 송신자의 주소를 파싱
   char *filename = NULL;
   filename = strchr(ip_filename,' ');  //파일명을 파싱함.
   filename++;
   filename[strlen(filename)]='\0';

  memset(&saddr, 0, sizeof(saddr));
  saddr.sin_family = AF_INET;
  saddr.sin_addr.s_addr = inet_addr(ip);
  saddr.sin_port = htons(port);
  sockfd=socket(AF_INET, SOCK_STREAM, 0);

  connect(sockfd, (struct sockaddr*)&saddr, sizeof(saddr)); //송신자에 연결

  fd = open(filename, O_WRONLY| O_CREAT| O_TRUNC, 666); //전송 받을 파일명으로 파일 생성
 printf("filename : %s && fd : %d",filename,fd);
  while((cnt=recv(sockfd, buf, bufsize, 0)) > 0 ){ //새로 만든 파일에 송신자로 부터 받은 바이트를 쓴다.
  // printf("%s",buf);
  write(fd, buf, cnt);
   }
  close(fd); //소켓 닫음
  close(sockfd);
}

void *send_thread(void *filename){  //파일 전송시 사용될 함수. 스레드로 처리됨.
 struct sockaddr_in saddr, caddr; 
 int sockfd, newsockfd;
 char buf[bufsize];
 int fd;
 int cnt, cli_len;
 memset(&saddr, 0, sizeof(saddr));
 saddr.sin_family = AF_INET;
 saddr.sin_addr.s_addr = htonl(INADDR_ANY);
 saddr.sin_port = htons(port);
 sockfd = socket(AF_INET,SOCK_STREAM,0);
 bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));

 printf("\nREADY\n");
 listen(sockfd, max);  //수신자의 접속을 기다리고 있음
 while(1){
  cli_len = sizeof(caddr);
  newsockfd=accept(sockfd, (struct sockaddr*)&caddr, &cli_len); //수신자가 접속을 하면 소켓 번호 할당.
 // filename[strlen(filename)-1]='\0';
 //printf("\nfile size : %d : |%s|\n",strlen(filename),filename);

  fd = open(filename, O_RDONLY); //송신하기로 한 파일 오픈 후 파일에 대한 번호 할당
 //printf("\nfd : |%d|\n",fd);
 while(read(fd, buf, bufsize) > 0){ //파일 바이트 읽어들이고
 //   printf("%s",buf);
  send(newsockfd, buf, strlen(buf),0); // 수신측에 전송한다.
 }

 close(newsockfd);
 close(fd);
 //close(sockfd);
 }
}

int main(int argc, char *argv[]) { //클라이언트
 char line[MAXLINE], message[MAXLINE+1];
   int n, pid;
   struct sockaddr_in server_addr;
   int maxfdp1;
 int s;  /* 서버와 연결된 소켓번호 */
 char server_address[30];
 
 pthread_t t_id;
  fd_set read_fds;
 
  if(argc != 4) {
     printf("사용법 : %s sever_IP port name \n", argv[0]);
     exit(0);
  }

  /* 채팅 참가자 이름 구조체 초기화 */
  sprintf(name, "[%s]", argv[3]);

  /* 소켓 생성 */
  if ((s = socket(PF_INET, SOCK_STREAM, 0)) < 0) {
     printf("Client : Can't open stream socket.\n");
     exit(0);
  }
 struct hostent *host = gethostbyname(argv[1]);  //호스트의 이름으로 부터 주소를 얻기 위해 gethostbyname사용.
 InetAddress myaddr;

 
 //클라이언트 실행시 두가지로 실행시킬 수가 있다.
 //도메인으로 서버의 주소를 지정할 것인가. 아이피로 서버의 주소를 지정할 것인가이다.
 // ex1) ./client sce.sejong.ac.kr 9887 nonnous                             ex2) ./client 127.0.0.1 9887 nonnous

 if(host!=NULL){   //sce.sejong.ac.kr 와 같이 도메인 주소로 입력되었을 경우 십진 주소로 변환하는 작업
  myaddr.my_ip =  *((unsigned long*)host->h_addr_list[0]) ;   //호스트의 주소를 long형으로 반환하고
  strcpy(server_address,inet_ntoa( myaddr.my_addr )); // 십진 주소형태의 문자열로 만들어 server_address에 할당한다.
 }else{     // 도메인이 아닌 십진 IP Address로 입력했을 경우엔 변환이 필요없이 바로 접속하면 된다.
  

  strcpy(server_address,argv[1]);
 }

 printf("\n서버 주소 %s\n",server_address);

  /* 채팅 서버의 소켓주소 구조체 server_addr 초기화 */
  bzero((char *)&server_addr, sizeof(server_addr));
  server_addr.sin_family = AF_INET;             
  server_addr.sin_addr.s_addr = inet_addr(server_address);
  server_addr.sin_port = htons(atoi(argv[2]));     

  /* 연결요청 */
 if(connect(s, (struct sockaddr *)&server_addr, sizeof(server_addr)) < 0) { //서버에 접속 요청
  printf("Client : Can't connect to server.\n");
  exit(0);
 }else {
  printf("SERVER CONNECTED~!. \n");
   send(s, argv[3], strlen(argv[3]), 0);
 }
 
 maxfdp1 = s + 1;
 FD_ZERO(&read_fds);

    while(1) { //무한 루프를 돌며 메시지를 송신하거나 수신한다.
  FD_SET(0, &read_fds);
  FD_SET(s, &read_fds);

     if(select(maxfdp1, &read_fds, (fd_set *)0, (fd_set *)0, (struct timeval *)0) < 0)  {
       printf("select error\n");
       exit(0);
     }
     if (FD_ISSET(s, &read_fds))  {
       int size;
       if ((size = recv(s, message, MAXLINE, 0)) > 0)  { //서버로 부터 온 메시지를 받는다.
          message[size] = '\0';
   
    if(message[0]=='/'){ //파일 전송                                         //서버로부터 온 메시지가 일반 메시지가 아닌
     char *option = mid(message,1,strcspn(message," "));       // 미리 약속한 신호 메시지일 경우 특정 루틴을 실행하기
     char temp_buff[244]= {0};                                              // 위해 파싱한다.
    
     printf("\n|message : %s|\n",message);
     if(strcmp(option,"/tr")==0){  // 이 메시지는 다른 클라이언트가 파일을 보내길 원할 때 서버로부터 전송되어 진다.
              //       여기에 해당될 경우          /tr 주소 파일명    ex) /tr 210.107.236.150 readme.txt  형태로 온다.             
      char *ip_filename  = strchr(message,' ');  //필요한 정보만 얻기 위해 메시지를 파싱하여 앞에 "/tr"을 제거한다.
      ip_filename++;
     
      recv_thread(ip_filename); //송신자의 주소와 전송받을 파일명을 recv_thread에 넘겨준다.
   
     }
     else if(strcmp(option,"/reply")==0){ // 이 메시지는 다른 클라이언트로 파일을 보내길 원할 때 요청 메시지를 보내고
                                                       // 그에 대한 응답으로 서버로 부터 받는 메시지 이다.
    
      char *option_filename  = strchr(message,' '); 
     option_filename++;
     char *option2 =  mid(option_filename,1,strcspn(option_filename," "));
     char *filename = strchr(option_filename,' ');
     char *trash = strchr(filename,' ');
     filename++;
     printf("\n%s 전송합니다.\n",trash);
     pthread_create(&t_id,NULL,send_thread,filename); //스레드를 실행하여 송신과 채팅이 병렬적으로 이루어질수
                       //있도록 한다.
  
     }
    }else{
           printf("%s \n", message);// 일반적인 메시지일 경우 별다른 프로세싱을 거치지 않고 클라이언트에 출력된다.
    }
  
       }
     }

     if (FD_ISSET(0, &read_fds)) {
   if(fgets(message, MAXLINE, stdin)) {
            sprintf(line, "%s %s", name, message);
            if (send(s, line, strlen(line), 0) < 0)
               printf("Error : Write error on socket.\n");
    if (strstr(message, escapechar) != NULL ) {
     printf("Good bye.\n");
     close(s);
     exit(0);
            }
       }
    }   
  } 
  return 0;
}

각종 헤더파일들

유저리스트 헤더파일

typedef struct user_node //사용자에 대한 정보를 가지는 구조체
{
 int socketfd; //소켓번호
 char *user_name; //사용자 닉넴
 char user_ip[16] ; //사용자의 아이피
 int room; // 사용자가 속해있는 방( 0 번이면 대기실, 그 외엔 방번호)
 struct user_node *next;
}user_node;

typedef struct room_node //방에 대한 정보를 가지는 구조체
{
 int room_number;  //방번호
 char *room_name; //방의 이름
 struct room_node *next;
 int user_num; //방에 속해있는 유저의 수
}room_node;

user_node *user_head=NULL;
room_node *room_head=NULL;
int room_number = 1;

void insert_user_node(int socketfd,char *name,char *ip);
void display();
void delete_user_node(int socketfd);
void delete_room_node(int room_num);
int get_user_room(int socketfd);
int confirm_room(int room);
user_node * get_user_node_by_socketfd(int socketfd);
int get_user_number_in_room(int room_num);
char** get_user_list(int room_num);

//////////////////////// 사용자 리스트 관련 함수 /////////////////////////////////////////////////

void insert_user_node(int socketfd,char *name,char *ip){ //사용자를 리스트에 추가하는 함수
 
 user_node *new_node;
 new_node = (user_node *) malloc(sizeof(user_node));
 new_node->socketfd = socketfd;
 new_node->user_name = (char *)malloc(sizeof(name));
 strcpy(new_node->user_ip,ip);
 new_node->room = 0;

 strcpy(new_node->user_name,name);

 new_node->next = NULL;
  
 
 if(user_head==NULL){ //처음 들어오는 사용자일 경우
  user_head = new_node;
  
 }else{
  user_node *temp = user_head;
  while(temp->next!=NULL){
   temp = temp->next;
  }
  temp->next = new_node;

 }

}

void display(){  //현재 접속한 사용자의 목록을 서버에서 확인 할때 사용하는 함수
                 //실제로 사람이 접속할 때마다 출력되게 된다.
 user_node *temp = user_head;
 printf("\n-------사용자 목록-----------\n");
 while(temp!=NULL){
   
   printf("%s(%s)->",temp->user_name,temp->user_ip);
   temp = temp->next;
 }
 printf("\n-------사용자 목록-----------\n");

}

int get_user_socketfd(int k){  //유저 리스트의 특정 번째에 있는 사용자의 소켓번호를 가지고 온다.
 int i=0;                             // 브로드캐스팅 시나 FD_SET 설정시에 사용됨
 user_node *p = user_head;
 for(i=0;i<k;i++){
  p=p->next;
 }
 return p->socketfd;
}

user_node * get_user_node_by_socketfd(int socketfd){  //소켓 번호를 통해 특정 유저의 노드를 얻어온다.
 user_node *p = user_head;
 while(p->socketfd !=socketfd){
  p = p->next;
 }
 return p;
}

void delete_user_node(int socketfd){   //유저가 채팅창을 끌때, 프로그램에서 완전히 나갈때 유저 삭제시 사용

 user_node *temp = user_head;
 user_node *prev = temp;
 int i=0;
 if(get_user_num()==1){  //사용자가 마지막 한명일때
 
  free(user_head);
  user_head=NULL;
 
 }else{
  while(temp->socketfd!=socketfd){ 
   if(temp->next==NULL){
    temp = temp->next;
    break;
   }
   prev = temp;
   temp = temp->next;
  }

  if(temp==user_head){  //맨 첫번째 노드의 사용자를 삭제하려할때
   user_head = temp->next;
   free(temp);
  }
  else if(temp!=NULL){  //맨첫번째 노드의 사용자 삭제 외에 모든 경우
   //printf("%d",temp->socketfd);
   prev->next = temp->next;
   free(temp);
   
  }else{
   printf("찾을수 없습니다."); //사용자가 아이디 잘못 입력시에
  }
 }

}

int get_user_num(){  //사용자의 총 숫자를 리턴.
 user_node *p = user_head;
 int i=1;
 if(p!=NULL){
  while(p->next!=NULL){
   p = p->next;
   i++;
  }

  return i;
 }else{
  return 0;
 }

}

int get_user_room(int socketfd){  //특정 소켓번호를 가진 사용자가 어느 방에 있는지 알아낼때 사용됨
 user_node *p = user_head;
 while(p->socketfd !=socketfd){
  p = p->next;
 }
 if(p==NULL)
  return 0;
 return p->room;  //방번호 반환
}

int get_sockerfd_by_user_name(char *name){  //사용자의 닉네임으로 사용자의 소켓번호를 얻어온다.
 user_node *p = user_head;
 while(p!=NULL){
  if(strcmp(p->user_name,name)==0){
   break;
  }
  p = p->next;
 }

 if(p==NULL)
  return 0; //없음
 else
  return p->socketfd;
}
char * get_user_name_by_socketfd(int socketfd){ //사용자의 소켓번호로 사용자의 닉네임을 얻어온다.
 user_node *p = user_head;
 while(p!=NULL){
  if(p->socketfd==socketfd)
   break;
  p=p->next;
 }
 return p->user_name;
}

char * get_user_ip_by_socketfd(int socketfd){ //사용자의 소켓번호로 사용자의 아이피를 얻어온다.
 user_node *p = user_head;                        //파일 전송시 사용됨
 while(p!=NULL){
  if(p->socketfd==socketfd)
   break;
  p=p->next;
 }
 return p->user_ip;

}

char *get_user_ip_by_user_name(char *user_name){ //사용자의 닉네임으로 사용자의 아이피를 얻어온다.
 user_node *p = user_head;
 while(p!=NULL){
  if( strcmp(p->user_name,user_name)==0)
   break;
  p=p->next;
 }

 return p->user_ip;
}

///////////////////////////사용자 리스트 관련 함수 끝/////////////////////////
/////////////////////////// 방 리스트 관련 함수 시작 /////////////////////////
int insert_room_node(char *name){  // 방개설시 사용됨.
 room_node *new_node;
 new_node = (room_node *) malloc(sizeof(room_node));
 new_node->user_num = 1; //개설 되자마자 입장 되므로
 new_node->room_name = (char *)malloc(sizeof(name));
 strcpy(new_node->room_name,name);
 new_node->room_number = room_number++;
 new_node->next=NULL;

 if(room_head==NULL){
  
  room_head = new_node;
 }else{
  room_node *temp = room_head;
  while(temp->next!=NULL){
   temp = temp->next;
  }
  temp->next = new_node;
 }
 
 return new_node->room_number;
}

void room_display(){  //방 목록을 서버에서 보려고 할때 사용된다.
 
 room_node *temp = room_head;

 printf("\n-------방 목록-----------\n");
 while(temp!=NULL){
   
   printf("방 번호 : %d | 방제목 : %s |  인원수 %d\n",temp->room_number,temp->room_name,temp->user_num);
   temp = temp->next;
 }
 printf("\n-------방 목록-----------\n");

}

int get_room_num(){  //존재하는 방의 개수를 반환한다.
 room_node *p = room_head;
 int i=1;
 if(p!=NULL){
  while(p->next!=NULL){
   p = p->next;
   i++;
  }
 }else{
  return 0;
 }
 return i;
}

void delete_room_node(int room_num){ //방을 삭제하려할때 호출된다.
               //사용자가 임의로 방을 삭제하는 것은 안되므로 마지막 사용자가 나갈때
               //자동으로 호출된다.
 room_node *temp = room_head;
 room_node *prev = temp;
 int i=0;

 if(confirm_room(room_num)==0){
  printf("방을 찾을수 없습니다.");
 }
 if(get_room_num()==1){
  
  free(room_head);
  room_head=NULL;
 
 }else{
  while(temp->room_number!=room_num){
   if(temp->next==NULL){
    temp = temp->next;
    break;
   }
   prev = temp;
   temp = temp->next;
  }

  if(temp==room_head){
   room_head = temp->next;
   free(temp);
  }
  else if(temp!=NULL){
   //printf("%d",temp->socketfd);
   prev->next = temp->next;
   free(temp);
   
  }else{
   printf("찾을수 없습니다.");
  }
 }

}

int confirm_room(int room){  //방이 실제로 존재하는지 확인한다.
 room_node *temp = room_head;
 int i=0;
 while(temp!=NULL){
  
  if(temp->room_number==room)
   i=1;

  temp= temp->next;
 }
 return i;

}

char *room_info(){  //사용자가 대화방에 대한 정보를 보려할때 제공하기 위해 방에 대한 정보를 문자열로 반환한다
 char *info,*temp_char,**list=NULL;
 info = (char*) malloc(2048);
 temp_char = (char*) malloc(1024);
 
 room_node *temp = room_head;
 int j=0,i=0;

 //printf("room num : %d",get_room_num());
 for(j=0;j<get_room_num();j++){
  
  sprintf(temp_char,"방 번호 %d  방제목 : %s 인원수 %d\n유저 목록 : ", temp->room_number,temp->room_name,temp->user_num);

  list = get_user_list(temp->room_number);
  
  
  if(j==0)
   strcpy(info,temp_char);

  else{
   strcat(info,temp_char);
  }
  for(i=0;i<temp->user_num;i++){
   strcat(info,list[i]);
   strcat(info,"\t");
  }
  strcat(info,"\n");
  temp = temp->next;

 }
 
 
 return info;
}

int user_out_of_room(int room_num,int socketfd){  //사용자가 대화방 밖으로 나가려할때 처리를 맡는다.
 room_node *temp = room_head;                      //여기서 대화방의 마지막 사용자일때 delete_room_node가 호출되어 방을
 if(socketfd!=0){                                               //삭제한다.
  user_node *user_temp =  get_user_node_by_socketfd(socketfd);
  user_temp->room =0;
 }
 while(temp->room_number!=room_num){
  temp = temp->next;
 }
 
 temp->user_num--;
 if(temp->user_num==0){
  delete_room_node(room_num);
 }
 return temp->user_num;
}

int user_join_room(int room_num,int socketfd){  //사용자가 방에 입장하려 할때 사용자의 정보와 방에 대한 정보를
 //특정 방에 사용자 입장                          // 변경하여 사용자가 대화방으로의 입실을 처리한다.
 room_node *room_temp = room_head;
 user_node *user_temp =  get_user_node_by_socketfd(socketfd);
 if(room_head==NULL)
  return 0;
 while(room_temp->room_number!=room_num){
  if(room_temp->next==NULL){
   return 0;
  }
  room_temp = room_temp->next;
 } //사용자가 원하는 노드를 찾는다.
 
 user_temp->room = room_num;
 room_temp->user_num++;

 return 1;
}

char** get_user_list(int room_num){    //대화방 사용자의 목록을 출력.
 user_node *temp = user_head;
 char **list;
 int i=0;
// array = (int **)malloc(sizeof(int) *a);       
 list = (char **)malloc(sizeof(char)*get_user_number_in_room(room_num));
 
 while(temp!=NULL){
  if(temp->room==room_num){
   list[i] = (char *)malloc(strlen(temp->user_name));
   strcpy(list[i++],temp->user_name);
   //printf("\n%s\n",list[i++]);
  }
  temp = temp->next;
 }

 return list;

}
char** get_user_list_all(){  //총 접속한 사용자의 목록을 출력
 user_node *temp = user_head;
 int total = get_user_num();
 char **list;
 int i=0;
 list =(char **)malloc(sizeof(char)*total);
 
 while(temp!=NULL){
  list[i] =(char *)malloc(strlen( temp->user_name));
  strcpy(list[i++],temp->user_name);
  temp=temp->next;
 }
}

int get_user_number_in_room(int room_num){  //대화방의 사용자수를 반환한다.
 
 room_node *temp = room_head;
 while(temp->room_number != room_num){
  temp = temp->next;
 }
 return temp->user_num;
}

마이 유틸 헤더파일

char* mid(char* str,int a,int b) //문자열 자를때 사용. 특정 부분을 원하는 만큼 자를수 있다.
{
    int i,midcnt=0;
    int strl=strlen(str);
 char* pstr= (char *)malloc(strl);
    strcpy(pstr,str);
    if( a > strl || a+b> strl+1 || a == 0 || b == 0) // a,b 값 체크
    {
        if( a==0 || b==0 )
            printf(" a or b is not Zero...\n");
        printf("Invalid parameter a or b check...");
        exit(1);    // 강제 종료
    }
    // pstr 처리 부분.
    for ( i = a-1 ; i < a-1+b ; i++)
        pstr[midcnt++] = pstr[i];
    pstr[midcnt]='\0';
 
 return pstr;
}


트랜스퍼 헤더 파일


#define port 7979
#define max 5
#define bufsize 1024

//쓰레드에서 쓰이기 때문에 모두 void * 임.
void recv_thread(char *ip,char *filename){ //클라이언트가 서버에 접속하여 다운 받는 방식.
 struct sockaddr_in saddr;        
 int sockfd;                       
 char buf[bufsize]={0};
 int fd;
 int cnt;
 memset(&saddr, 0, sizeof(saddr));
 saddr.sin_family = AF_INET;
 saddr.sin_addr.s_addr = inet_addr(ip);
 saddr.sin_port = htons(port);

 sockfd=socket(AF_INET, SOCK_STREAM, 0);

 connect(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));

 fd = open(filename, O_WRONLY| O_CREAT| O_TRUNC, 666);
 printf("파일을 수신합니다.");
 while((cnt=recv(sockfd, buf, bufsize, 0)) > 0 ){
  printf("%s",buf);
  write(fd, buf, cnt);
 }
 close(fd);
 close(sockfd);
 
}

void send_thread(char *filename){
 struct sockaddr_in saddr, caddr;
 int sockfd, newsockfd;
 char buf[bufsize];
 int fd;
 int cnt, cli_len;

 memset(&saddr, 0, sizeof(saddr));
 saddr.sin_family = AF_INET;
 saddr.sin_addr.s_addr = htonl(INADDR_ANY);
 saddr.sin_port = htons(port);

 sockfd = socket(AF_INET,SOCK_STREAM,0);
 bind(sockfd, (struct sockaddr*)&saddr, sizeof(saddr));

 listen(sockfd, max);

 //while(1){
  printf("파일을 전송합니다.");
  cli_len = sizeof(caddr);
  newsockfd=accept(sockfd, (struct sockaddr*)&caddr, &cli_len);

  fd = open(filename, O_RDONLY);
  while(read(fd, buf, bufsize) > 0){
   send(newsockfd, buf, strlen(buf),0);
  }

  close(newsockfd);
 //}

}