/*
   * tipc.c
   *
   *  Created on: 2015. 9. 1.
   *      Author: jwjw
   */
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <string.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <signal.h>
  #include <errno.h>
  #include <sys/types.h>
  #include <sys/un.h>
  #include <sys/socket.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <sys/un.h>
  #include <sys/socket.h>
  #include <sys/poll.h>
  #include <netinet/in.h>
  #include <arpa/inet.h>
  #include <pthread.h>
  #include <linux/tipc.h>
  
  #include <util.h>
  #include <tlist.h>
  #include <pollmng.h>
  #include <tipc.h>
  
  /// tcp 소켓의 형태를 구분한다.
  #define  SOCK_TYPE_CLIENT          0
  #define  SOCK_TYPE_SERVER          1
  #define  SOCK_TYPE_SERVER_CLIENT   2
  
  /// tcp 개별 구조체
  typedef struct {
  
      int   type;
      int   inst;
  
      // 서버용 정보
      tlist *client_list;
      int    client_max;
      int    sock_type;
      poll_obj_t *obj_server;   // 서버에서 분리된 클라이언트를 위해
  } tipc_priv_t;
  
  
  poll_obj_t  *tipc_open_server( int type, int inst, int client_max)
  {
      struct sockaddr_tipc server_addr;
  
      server_addr.family              = AF_TIPC;
      server_addr.addrtype            = TIPC_ADDR_NAMESEQ;
      server_addr.addr.nameseq.type   = type;
      server_addr.addr.nameseq.lower  = inst;
      server_addr.addr.nameseq.upper  = inst;
      server_addr.scope               = TIPC_ZONE_SCOPE;
  
      int sockfd  = socket (AF_TIPC, SOCK_SEQPACKET, 0);
      if ( sockfd < 0 ){
          perror( "tipc server open error:" );
          return NULL;
      }
  
  
      if (0 != bind( sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr))) {
          perror("tipc bind error :");
          close( sockfd );
          return NULL;
      }
  
      if (0 != listen( sockfd, 0)) {
          perror("tipc listen error :");
          close( sockfd );
          return NULL;
      }
  
      // tcp 만의 정보를 설정한다.
      tipc_priv_t *tipc   = (tipc_priv_t *)malloc( sizeof(tipc_priv_t) );
  
      tipc->sock_type     = SOCK_TYPE_SERVER;
      tipc->type          = type;
      tipc->inst          = inst;
      tipc->client_max    = client_max;
      tipc->client_list   = tlist_create();
  
      // 폴관리객체에 등록한다.
      poll_obj_t *obj = poll_add( sockfd );
      obj->type = STYP_TIPC;
      obj->priv = (void *)tipc;
  
      poll_rebuild();
  
      return obj;
  }
  
  poll_obj_t  *tipc_open_client( int type, int inst )
  {
      struct sockaddr_tipc server_addr;
  
  
      server_addr.family                  = AF_TIPC;
      server_addr.addrtype                = TIPC_ADDR_NAME;
      server_addr.addr.name.name.type     = type;
      server_addr.addr.name.name.instance = inst;
      server_addr.addr.name.domain        = 0;
  
      int sockfd  = socket (AF_TIPC, SOCK_SEQPACKET, 0);
      if ( sockfd < 0 ){
          perror( "tipc open error:" );
          return NULL;
      }
  
      if ( 0 != connect( sockfd, (struct sockaddr *)&server_addr, sizeof(server_addr)) ) {
          perror( "tipc connect error :" );
          close( sockfd );
          return NULL;
      }
  
  
      poll_obj_t *obj;
      tipc_priv_t *tipc = (tipc_priv_t *)malloc( sizeof(tipc_priv_t) );
  
      tipc->sock_type     = SOCK_TYPE_SERVER;
      tipc->type          = type;
      tipc->inst          = inst;
  
      // 폴관리객체에 등록한다.
      obj = poll_add( sockfd );
      obj->type = STYP_TIPC;
      obj->priv = (void *)tipc;
  
      return obj;
  }
  
  //------------------------------------------------------------------------------
  /** @brief    tcp 소켓을 close 한다.
      @param    obj  폴객체 포인터
  *///----------------------------------------------------------------------------
  void tipc_close( poll_obj_t *obj )
  {
      tipc_priv_t *tipc, *server_tipc;
  
      if ( obj->on_disconnect ){                          // 소켓 끊어짐을 사용자에게 알린다.
          obj->on_disconnect( obj );
      }
  
      tipc = (tipc_priv_t *)obj->priv;
  
      switch( tipc->sock_type )
      {
      case SOCK_TYPE_SERVER_CLIENT :
          // 서버가 관리하는 클라이언트를 리스트에서 삭제
          server_tipc = (tipc_priv_t *)(tipc->obj_server->priv);
          if ( server_tipc  ){
              tlist_remove( server_tipc->client_list, obj );
          }
          break;
      case SOCK_TYPE_SERVER :
          tlist_free( tipc->client_list );                        // 서버가 관리하는 클라이언트의 server_tipc 를 모두 NULL 로 만든다.
          break;
      }
  
      shutdown( obj->fd, SHUT_RDWR);
      close( obj->fd );
      if ( obj->priv ){
          free( obj->priv );
      }
  
      poll_delete( obj );
  }
  
  
  static poll_obj_t  *tipc_connect_client( poll_obj_t *obj_server, int sockfd)
  {
      // 클라이언트 접속의 개수를 파악한다.
      tipc_priv_t *server_tipc = (tipc_priv_t *)obj_server->priv;
      if ( tlist_getcount(server_tipc->client_list) >= server_tipc->client_max ){
          shutdown(sockfd, SHUT_RDWR);
          close( sockfd );
          printf( "tipc connect error : client is full (%d)
  ", server_tipc->client_max );
          return NULL;
      }
  
      // tipc 만의 정보를 설정한다.
      tipc_priv_t *tipc = (tipc_priv_t *)malloc( sizeof(tipc_priv_t) );
  
      tipc->sock_type    = SOCK_TYPE_SERVER_CLIENT;
      tipc->obj_server   = obj_server; // 클라이언트 소켓을 할당한 서버정보
  
      // 폴관리객체에 등록한다.
      poll_obj_t *obj = poll_add( sockfd );
      if ( obj ){
          // 서버에 접속된 클라이언트를 리스트에 등록
          tlist_add( server_tipc->client_list, obj );
  
          obj->type = STYP_TIPC;
          obj->priv = (void *)tipc;
          return obj;
      } else {
          shutdown(sockfd, SHUT_RDWR);
          close( sockfd );
          free( tipc );
          return NULL;
      }
  }
  
  poll_obj_t  *tipc_accept_client( poll_obj_t *obj_server )
  {
      int peer_sd = accept( obj_server->fd, 0, 0);
  
      if (peer_sd < 0 ) {
          printf ("Server: accept failed
  ");
          exit(1);
      }
  
      return tipc_connect_client( obj_server, peer_sd);
  }
  
  //------------------------------------------------------------------------------
  /** @brief    tipc 소켓을 통해 데이타를 전송한다.
      @param    obj     폴객체 포인터
      @param    buf     전송버퍼
      @param    len     버퍼의 길이
      @return   전송한 데이타 개수
      @remark   에러에 대한 처리를 해야한다.
                tipc_close( obj ) 를 호출하여 접속을 끊는 방법이 일반적이다.
                BF_POLICY_AUTO_CLOSE 옵션이 있을경우 자동으로 소켓을 닫는다.
  *///----------------------------------------------------------------------------
  int  tipc_write( poll_obj_t *obj, char *buf, int len )
  {
      int  wrcnt = write( obj->fd, buf, len );
  
      if ( 0 > wrcnt ){
          perror( "[sys]tipc send error:" );
          tipc_close( obj );
      }
  
      return wrcnt;
  }
  
  //------------------------------------------------------------------------------
  /** @brief    tipc 소켓을 통해 데이타를 읽는다.
      @param    obj     폴객체 포인터
      @param    len     버퍼의 길이
      @return   전송된 데이타 개수
      @remark   에러에 대한 처리를 해야한다.
                tipc_close( obj ) 를 호출하여 접속을 끊는 방법이 일반적이다.
                BF_POLICY_AUTO_CLOSE 옵션이 있을경우 자동으로 소켓을 닫는다.
  *///----------------------------------------------------------------------------
  int  tipc_read( poll_obj_t *obj, char *buf, int len )
  {
      int rdcnt = read( obj->fd, buf, len );
      if ( 0 > rdcnt ) {
          perror( "tipc recv error:" );
  
  #if 0
          if ( bf_policy & BF_POLICY_CLOSE_IOERR ){
              tipc_close( obj );
          }
  #endif
          tipc_close( obj );
      }
      else if ( 0 == rdcnt ){
          if ( 0 > errno )
          {
              perror( "tipc recv error:" );
  #if 0
              if ( bf_policy & BF_POLICY_CLOSE_IOERR )
              {
                  tipc_close( obj );
              }
  #endif
              tipc_close( obj );
          }
          else
          {
  #if 0
              if ( bf_policy & BF_POLICY_READ_ZERO_ERROR )
              {
                  printf( "tipc read 0 error: close socket
  " );
                  tipc_close( obj );
              }
  #endif
              tipc_close( obj );
          }
      }
  
      // 정책에 대한 결정을 한다.
      tipc_priv_t *tipc = (tipc_priv_t *)obj->priv;
      if ( tipc->sock_type  == SOCK_TYPE_SERVER_CLIENT )
      {
  #if 0
          if ( bf_policy & BF_POLICY_RELOAD_TIMEOUT )
          {
              tipc->life_sec = get_cur_sec() + tipc_live_sec;
          }
  #endif
      }
  
      return rdcnt;
  }