http proxy 개발 문의드립니다.

void *webj_proxy( void *data )
{
 
  int i = 0;
  int ret = 0;
  int opt = 1;
  int state = 0;
  int client_len = 0;
  int client_sockfd = 0;
  int recv_size = 873800;
  int pth_id = 0;
  int optval = 0;
  int optlen = 0;
  struct sockaddr_in  server_addr, client_addr, my_addr;
  struct linger ling;
 
  //pthread_detach(pthread_self());
 
  server_sockfd = socket( AF_INET, SOCK_STREAM, 0 );
  if ( server_sockfd < 0 ) {
    return NULL;
  }
 
  //setsockopt( server_sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt) );
 
  setsockopt( server_sockfd, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt) );
 
// optlen = sizeof(optval);
// getsockopt( server_sockfd, SOL_SOCKET, SO_RCVBUF, (void *)&optval, &optlen );
// printf("before optval = %d ",optval);
//
// ling.l_onoff = 1;
// ling.l_linger = 0;
// setsockopt( server_sockfd, SOL_SOCKET, SO_LINGER, &ling, sizeof(ling));
 
  bzero( &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(8080);
 
  state = bind( server_sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr) );
  if ( state < 0 ) {
    close(server_sockfd);
    return NULL;
    //return -1;
  }
 
  state = listen( server_sockfd, 1);
  if ( state < 0 ) {
    return NULL;
  }
 
  for ( i = 0 ; i < 100 ; i++ ) {
    c_data[i].pth_pid = -1;
    c_data[i].c_sfd = -1;
  }
 
  while ( 1 ) {
    client_sockfd = accept( server_sockfd, (struct sockaddr *)&client_addr, (socklen_t *)&client_len );
 
    getpeername(client_sockfd, (struct sockaddr *)&my_addr, (socklen_t *)&client_len);
 
    printf("client port is %d\n",my_addr.sin_port);
    printf("client ip is %s\n",inet_ntoa(my_addr.sin_addr));
    printf("client sockfd:%d\n",client_sockfd );
 
    for ( i = 0 ; i < 100 ; i++ ) {
      if ( c_data[i].pth_pid == -1 ) break;
    }
 
    if ( i >= 100 ) {
      printf("pthread error!!!\n");
      close( client_sockfd );
      continue;
    }
 
    c_data[i].c_sfd = client_sockfd;
    pth_id = pthread_create( &c_data[i].pth_pid, NULL, webj_remote, (void *)&i );
  }
 
  return NULL;
 
}

void *webj_remote( void *data )
{
 
  int pth_num = 0;
  int ret = 0;
  int len = 0;
  int contentlength = 0;
  int remote_sockfd = 0;
  char *szHeaderValue = NULL;
  char buff[1024];
  char recv_buff[8192];
  char tmp_buff[8192];
  char hostname[256];
  unsigned long ip;
 
  pthread_detach (pthread_self());
 
  pth_num = *((int *)data);
 
  memset( buff, 0x00, 1024 );
  memset( recv_buff, 0x00, 8192 );
  memset( tmp_buff, 0x00, 8192 );
  memset( hostname, 0x00, 256 );
  contentlength = 0;
 
  len = recv ( c_data[pth_num].c_sfd, recv_buff, 8192, 0 );
  recv_buff[strlen(recv_buff)] = '\0';
 
  strncpy( tmp_buff, recv_buff, sizeof(recv_buff) );
 
  remote_sockfd = webj_connect( hostname );
 
  if ( remote_sockfd == -1 ) {
    close( remote_sockfd );
    close( c_data[pth_num].c_sfd );
 
    pthread_mutex_lock(&mutex_lock);
    c_data[pth_num].pth_pid = -1;
    c_data[pth_num].c_sfd = -1;
    pthread_cond_signal(&thread_cond);
    pthread_mutex_unlock(&mutex_lock);
    return NULL;
  }
 
  ret = send ( remote_sockfd, recv_buff, len, 0 );
 
  memset( recv_buff, 0x00, 8192 );
  len = recv ( remote_sockfd, recv_buff, 8192, 0 );
  recv_buff[strlen(recv_buff)] = '\0';
  send ( c_data[pth_num].c_sfd, recv_buff, len, 0);
 
  webj_recvandsnd( remote_sockfd, c_data[pth_num].c_sfd );
 
  //memset( recv_buff, 0x00, 8192 );
  //while ( ( len = recv ( remote_sockfd, recv_buff, 8192, 0 ) ) > 0 ) {
  //
  //    buff[strlen(recv_buff)] = '\0';
  //    send ( c_data[pth_num].c_sfd, recv_buff, len, 0);
  //    //printf("22222222222222222recv len:%d\n", len );
  //    //printf("-------------------------------------------------------\n");
  //    //printf("%s\n", buff );
  //    //printf("-------------------------------------------------------\n");
  //    memset( recv_buff, 0x00, 8192 );
  //
  //}
 
  close( remote_sockfd );
  close( c_data[pth_num].c_sfd );
 
  pthread_mutex_lock(&mutex_lock);
  c_data[pth_num].pth_pid = -1;
  c_data[pth_num].c_sfd = -1;
  pthread_cond_signal(&thread_cond);
  pthread_mutex_unlock(&mutex_lock);
 
 
  return 0;
 
}

int webj_connect( char *hostname )
{
 
  int remote_sockfd = 0;
  int ret = 0;
  int opt = 1;
  int real_len = 0;
  char *ip = NULL;
  char ip_buff[4096];
  struct sockaddr_in  real_addr;
  struct hostent     *myent;
  struct linger ling;
 
  remote_sockfd = socket( AF_INET, SOCK_STREAM, 0 );
  if ( remote_sockfd < 0 ) {
      printf("1. client error:%s\n", strerror(errno) );
      return -1;
  }
 
  memset( ip_buff, 0x00, 4096 );
  get_ip( hostname, ip_buff, sizeof(ip_buff), &myent );
  if ( myent == NULL ) return -1;
 
  remote_sockfd = socket( AF_INET, SOCK_STREAM, 0 );
  real_addr.sin_family = AF_INET;
  memcpy ( &real_addr.sin_addr.s_addr, myent->h_addr, myent->h_length );
  printf("ipaddr:%s\n", inet_ntoa(real_addr.sin_addr) );
  //real_addr.sin_addr.s_addr = inet_ntoa( *(struct in_addr*)myent->h_addr_list[0]);
  //real_addr.sin_addr.s_addr = inet_addr("110.14.221.235");
  real_addr.sin_port = htons(80);
 
  //setsockopt( remote_sockfd, IPPROTO_TCP, TCP_NODELAY, &opt, sizeof(opt) );
 
  //optlen = sizeof(optval);
  //getsockopt( server_sockfd, SOL_SOCKET, SO_RCVBUF, (void *)&optval, &optlen );
  //printf("before optval = %d ",optval);
 
  real_len = sizeof(real_addr);
 
  ret = connect( remote_sockfd, (struct sockaddr *)&real_addr, real_len );
  if ( ret < 0 ) {
      printf("2. client error:%s\n", strerror(errno) );
      close(remote_sockfd);
      return -1;
  }
 
  return remote_sockfd;
}

int webj_recvandsnd( int recv_sfd, int send_sfd )
{
  int ret = 0;
  int recv_len = 0;
  int tmp_sock = 0;
  char buff[2048];
  struct timeval timeout;
  fd_set read_set;
 
  memset( buff, 0x00, 2048 );
 
  while ( 1 ) {
 
    FD_ZERO( &read_set );
    FD_SET( recv_sfd, &read_set );
 
    timeout.tv_sec = 3;
    timeout.tv_usec = 0;
 
    tmp_sock = recv_sfd;
 
    ret = select( tmp_sock + 1, &read_set, NULL, NULL, &timeout );
    if ( ret < 0 ) return -1;
 
    if ( FD_ISSET( tmp_sock, &read_set ) ) {
        recv_len = recv( tmp_sock, buff, 2048, 0 );
        if ( recv_len > 0 ) {
          send( send_sfd, buff, recv_len, 0 );
          memset( buff, 0x00, 2048 );
          recv_len = 0;
        }
        else return 0;
    }
    else return 0;
 
  }
 
  return 0;
}