void *SpeedFanNodePlugin::ListenerThread::Entry()
{
  if (!OpenSocket()) {
    // Failed to open socket
    return NULL;
  }

  // Use a 2048 byte buffer, Ethernet frame size is 1500
  const int bufferSize = 2048;
  char *buffer = new char[bufferSize];
  while (!TestDestroy()) {
    // Reset the socket after recieving a packet
    int ret = m_Socket.RecvFrom(buffer, bufferSize);
    if (ret > 0) {
      buffer[ret] = 0;
      ProcessBuffer(buffer);
    } else {
      // Reopen socket
      if (TestDestroy() || !OpenSocket()) {
        // We need to exit or we failed to re-open the socket
        break;
      }
    }
    Sleep(0);
  }

  delete [] buffer;

  return NULL;
}
Exemple #2
0
BOOL CIServer::Start(HWND hWnd, UINT uMsg, DWORD dwPort, DWORD dwMax)
{
	Destroy();
	
	// Open the socket
	if (	!OpenSocket() ||

			// Bind to TCP port
			!Bind( dwPort ) ||

			// Listen for connections
			!Listen( dwMax ) ||

			// Async operation
			!SetMessageTarget( hWnd, uMsg ) ||

			// Start callback thread
			!StartCallbacks() )
	{
		Destroy();
		return FALSE;
	} // end if

	return TRUE;
}
SOCK Tcp_Connect(const char *ip,uint16_t port,struct sockaddr_in *servaddr,int32_t retry)
{
	if(!ip)
		return INVALID_SOCK;

	memset((void*)servaddr,0,sizeof(*servaddr));
	servaddr->sin_family = INET;
	servaddr->sin_port = htons(port);
#ifdef _WIN
	servaddr->sin_addr.s_addr = inet_addr(ip);
#else
	if(inet_pton(INET,ip,&servaddr->sin_addr) < 0)
	{

		printf("%s\n",strerror(errno));
		return INVALID_SOCK;
	}
#endif	
	SOCK sock = OpenSocket(INET,STREAM,TCP);
	if(sock)
	{
		while(1)
		{
			if(0 == Connect(sock,(struct sockaddr*)servaddr,sizeof(*servaddr)))
				return sock;
			if(!retry)
				break;
		}
		CloseSocket(sock);
	}
	return INVALID_SOCK;
}
Exemple #4
0
BOOL CPort::Open(const char* pszFileName, BOOL fIsSocket)
{
    RIL_LOG_VERBOSE("CPort::Open() - Enter  fIsSocket=[%d]\r\n", fIsSocket);
    BOOL fRet = FALSE;

    if (NULL == pszFileName)
    {
        RIL_LOG_CRITICAL("CPort::Open() - pszFileName is NULL!\r\n");
        return FALSE;
    }

    if (!m_fIsPortOpen)
    {
        if (NULL == m_pFile)
        {
            m_pFile = new CFile();
        }

        if (fIsSocket)
        {
            fRet = OpenSocket(pszFileName);
        }
        else
        {
            fRet = OpenPort(pszFileName);
        }
    }
    else
    {
        RIL_LOG_CRITICAL("CPort::Open() - Port is already open!\r\n");
    }

    RIL_LOG_VERBOSE("CPort::Open() - Exit\r\n");
    return fRet;
}
Exemple #5
0
int32_t Tcp_Connect(const char *ip,uint16_t port,struct sockaddr_in *servaddr,int32_t retry)
{
    if(!ip)
        return -1;

    bzero(servaddr,sizeof(*servaddr));
    servaddr->sin_family = INET;
    servaddr->sin_port = htons(port);
    if(inet_pton(INET,ip,&servaddr->sin_addr) < 0)
    {

        printf("%s\n",strerror(errno));
        return -1;
    }

    HANDLE sock = OpenSocket(INET,STREAM,TCP);
    if(sock)
    {
        while(1)
        {
            if(0 == Connect(sock,(struct sockaddr*)servaddr,sizeof(*servaddr)))
                return sock;
            if(!retry)
                break;
        }
        CloseSocket(sock);
    }
    return -1;
}
int main(int argc, char *argv[]){


	//ARGS: IP PORT FILENAME
	char* IP = "";
	int port = 0;

	if(argc != 3){
		printf("please provide two parameters! (IP, port)\n");
		return 0;
	}else{
		IP = argv[1];
		port = atoi(argv[2]);
	}
	

	//OpenFile(filename);
	OpenSocket(IP,port);
	
	getCommands();


	//printf("Clientapp\n");
	return 0;
}
void MemoryWatcherUnix::Create()
{
	if (!LoadAddresses(File::GetUserPath(F_MEMORYWATCHERLOCATIONS_IDX)))
		return;
	if (!OpenSocket(File::GetUserPath(F_MEMORYWATCHERSOCKET_IDX)))
		return;
	m_running = true;
	m_watcher_thread = std::thread(&MemoryWatcherUnix::WatcherThread, this);
}
MemoryWatcher::MemoryWatcher()
{
  m_running = false;
  if (!LoadAddresses(File::GetUserPath(F_MEMORYWATCHERLOCATIONS_IDX)))
    return;
  if (!OpenSocket(File::GetUserPath(F_MEMORYWATCHERSOCKET_IDX)))
    return;
  m_running = true;
}
Exemple #9
0
Client::Client(const char *host, int portNum)
{
  OpenSocket();
  ConnectToHost(host, portNum);
  
  SendMsg(NetMsg(Ok, 23));
  GetResponse();

  Disconnect();
}
MemoryWatcher::MemoryWatcher() : m_context(1)
{
	if (!LoadAddresses(File::GetUserPath(F_MEMORYWATCHERLOCATIONS_IDX)))
	{
	  std::cout << "Failed to load MemoryWatcher addresses. Not watching memory." << std::endl;
		return;
	}
	
	if (!OpenSocket(File::GetUserPath(F_MEMORYWATCHERSOCKET_IDX)))
	  return;
	m_running = true;
}
void
nsGopherContentStream::OnCallbackPending()
{
    nsresult rv;

    // We have a callback, so failure means we should close the stream.
    if (!mSocket) {
        rv = OpenSocket(CallbackTarget());
    } else if (mSocketInput) {
        rv = mSocketInput->AsyncWait(this, 0, 0, CallbackTarget());
    }
 
    if (NS_FAILED(rv))
        CloseWithStatus(rv);
}
Exemple #12
0
void main(int argc, char **argv)
{
	if (OpenSocket())
	{
		printf("OpenSocket error\n");
		exit(-1);
	}

	DWORD mode = PROMISC_MODE_ON;
	if (SetPromiscMode(&mode))
	{
		printf("SetPromiscMode error\n");
		exit(-1);
	}

	fstream file;
	file.open("C:\\Users\\tausvo\\Desktop\\byvitya\\SocketSniffer\\Debug\\packets.log", ios::out);
	while(1)
	{
		IPHeader *packet = SniffPacket();
		printf("writing packet...\n");

		/*TCPHeader *tcpPacket = (TCPHeader*)malloc(packet->iph_len);
		memcpy(tcpPacket, &packet->iph_data, packet->iph_len);

		byte *tcpData = (byte*)malloc(packet->iph_len);
		memcpy(tcpData, &tcpPacket->tcph_data, packet->iph_len);

		char *tcpStrData = (char*)malloc(packet->iph_len);
		memcpy(tcpStrData, &tcpData[128], packet->iph_len);
		printf(tcpStrData);

		free(tcpStrData);   error, rewrite this components
		free(tcpData);

		free(tcpPacket);
		//vector<string> splitedCoockies;*/

		char *str = IPPacket2Str(packet);
		file.write(str,strlen(str));
		free(str);

		free(packet);
	}
	file.close();
}
Exemple #13
0
int32_t connector_connect(connector_t c,const char *ip,uint32_t port,on_connect call_back,void *ud,uint32_t ms)
{
	struct sockaddr_in remote;
	HANDLE sock;
	struct pending_connect *pc;	
	sock = OpenSocket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if(sock < 0)
		return -1;
	
	remote.sin_family = AF_INET;
	remote.sin_port = htons(port);
	if(inet_pton(INET,ip,&remote.sin_addr) < 0)
	{

		printf("%s\n",strerror(errno));
		return -1;
	}
	if(ms>0)
	{
		if(setNonblock(sock)!=0)
			return -1;
	}
	if(Connect(sock, (struct sockaddr *)&remote, sizeof(remote)) == 0)
	{
		//连接成功,无需要后续处理了,直接调用回调函数
		call_back(sock,ip,port,ud);
		return 0;
	}
	
	socket_t s = GetSocketByHandle(sock);

	pc = malloc(sizeof(*pc));
	pc->lnode.next = NULL;
	pc->sock = sock;
	pc->ip = ip;
	pc->port = port;
	pc->call_back = call_back;
	pc->timeout = GetSystemMs() + ms;
	pc->ud = ud;
	pc->real_fd = s->fd;
	mutex_lock(c->lock);
	LINK_LIST_PUSH_BACK(c->extern_pending_connect,pc);
	mutex_unlock(c->lock);
	return 0;
}
Exemple #14
0
SOCK Tcp_Listen(const char *ip,uint16_t port,int32_t backlog)
{
    struct sockaddr_in servaddr;
	SOCK sock;
	sock = OpenSocket(INET,STREAM,TCP);
	if(sock == INVALID_SOCK)
		return INVALID_SOCK;

	memset((void*)&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = INET;
	if(ip)
	{
		if(inet_pton(INET,ip,&servaddr.sin_addr) < 0)
		{

			printf("%s\n",strerror(errno));
			return INVALID_SOCK;
		}
	}
	else
		servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
	servaddr.sin_port = htons(port);
	
	if (set_reuseaddr(sock) != 0){
		CloseSocket(sock);
		return INVALID_SOCK;
	}

	if(Bind(sock,(struct sockaddr*)&servaddr,sizeof(servaddr)) == INVALID_SOCK)
	{
		CloseSocket(sock);
		return INVALID_SOCK;
	}

	if(Listen(sock,backlog) != INVALID_SOCK)
		return sock;
	else
	{
		CloseSocket(sock);
		return INVALID_SOCK;
	}
}
Exemple #15
0
SOCK Tcp_Listen(const char *ip,uint16_t port,struct sockaddr_in *servaddr,int32_t backlog)
{
	SOCK sock;
	sock = OpenSocket(INET,STREAM,TCP);
	if(sock < 0)
		return INVALID_SOCK;

	memset((void*)servaddr,0,sizeof(*servaddr));
	servaddr->sin_family = INET;
	if(ip)
	{
#ifdef _WIN
		servaddr->sin_addr.s_addr = inet_addr(ip);
#else
		if(inet_pton(INET,ip,&servaddr->sin_addr) < 0)
		{

			printf("%s\n",strerror(errno));
			return INVALID_SOCK;
		}
#endif	
	}
	else
		servaddr->sin_addr.s_addr = htonl(INADDR_ANY);	
	servaddr->sin_port = htons(port);

	if(Bind(sock,(struct sockaddr*)servaddr,sizeof(*servaddr)) < 0)
	{
		CloseSocket(sock);
		return INVALID_SOCK;
	}

	if(Listen(sock,backlog) == 0) 
		return sock;
	else
	{
		CloseSocket(sock);
		return INVALID_SOCK;
	}
}
Exemple #16
0
SOCK Tcp_Connect(const char *ip,uint16_t port)
{
	if(!ip)
		return INVALID_SOCK;

    struct sockaddr_in servaddr;
	memset((void*)&servaddr,0,sizeof(servaddr));
	servaddr.sin_family = INET;
	servaddr.sin_port = htons(port);
	if(inet_pton(INET,ip,&servaddr.sin_addr) < 0)
	{
		printf("%s\n",strerror(errno));
		return INVALID_SOCK;
	}
	SOCK sock = OpenSocket(INET,STREAM,TCP);
	if(sock != INVALID_SOCK)
	{
        if(INVALID_SOCK != Connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr)))
            return sock;
		CloseSocket(sock);
	}
	return INVALID_SOCK;
}
HANDLE Tcp_Listen(const char *ip,unsigned short port,struct sockaddr_in *servaddr,int backlog)

{
	HANDLE sock;
	sock = OpenSocket(INET,STREAM,TCP);
	if(sock < 0)
		return -1;

	bzero(servaddr,sizeof(*servaddr));
	servaddr->sin_family = INET;
	if(ip)
	{
		if(inet_pton(INET,ip,&servaddr->sin_addr) < 0)
		{

			printf("%s\n",strerror(errno));
			return -1;
		}
	}
	else
		servaddr->sin_addr.s_addr = htonl(INADDR_ANY);	
	servaddr->sin_port = htons(port);

	if(Bind(sock,(struct sockaddr*)servaddr,sizeof(*servaddr)) < 0)
	{
		CloseSocket(sock);
		return -1;
	}

	if(Listen(sock,backlog) == 0) 
		return sock;
	else
	{
		CloseSocket(sock);
		return -1;
	}
}
WinSocket_UDP::WinSocket_UDP (long *plOk, unsigned short usLocalPort,
                                char *pchLocalAdress, bool bEnableBroadcasts)
{ long        lError, lBindError;
  sockaddr_in RecvAddr;

  *plOk         = FALSE;
  m_bInitOK     = false;
  m_pcLocalVars = NULL;

  m_pcLocalVars = new t_WinSocket_UDP_LocalVars;
  memset (m_pcLocalVars, 0, sizeof(t_WinSocket_UDP_LocalVars));

  m_pcLocalVars->bIsServer          = false;
  m_pcLocalVars->bBroadcastsEnabled = bEnableBroadcasts;
  m_pcLocalVars->usPort             = usLocalPort;
  strncpy (m_pcLocalVars->achAdress, pchLocalAdress, 256); m_pcLocalVars->achAdress[255] = 0;

  if ((lError = OpenSocket()) <= 0) { *plOk = lError; return; } 

  RecvAddr.sin_family      = AF_INET;
  RecvAddr.sin_addr.s_addr = (pchLocalAdress) ? inet_addr(pchLocalAdress) : htonl(INADDR_ANY);
  RecvAddr.sin_port        = htons(usLocalPort);

  if (usLocalPort != 0)
  { lBindError = bind(m_pcLocalVars->Socket, (SOCKADDR *) &RecvAddr, sizeof(RecvAddr));
    if (lBindError == SOCKET_ERROR)
    { printf("ERROR: bind() failed: %ld\n", WSAGetLastError());
      *plOk = ERRSOCK_PORT_BIND;
      return;
    }
    m_pcLocalVars->bIsServer = true;
  }

  m_bInitOK = true;
  *plOk     = TRUE;
}
Exemple #19
0
int main(int argc,char **argv)
    {
    SSLStateMachine *pMachine;
    int nPort;
    int nFD;
    const char *szCertificateFile;
    const char *szKeyFile;
    char rbuf[1];
    int nrbuf=0;

    if(argc != 4)
	{
	fprintf(stderr,"%s <port> <certificate file> <key file>\n",argv[0]);
	exit(6);
	}

    nPort=atoi(argv[1]);
    szCertificateFile=argv[2];
    szKeyFile=argv[3];

    SSL_library_init();
    OpenSSL_add_ssl_algorithms();
    SSL_load_error_strings();
    ERR_load_crypto_strings();

    nFD=OpenSocket(nPort);

    pMachine=SSLStateMachine_new(szCertificateFile,szKeyFile);

    for( ; ; )
	{
	fd_set rfds,wfds;
	unsigned char buf[1024];
	int n;

	FD_ZERO(&rfds);
	FD_ZERO(&wfds);

	/* Select socket for input */
	FD_SET(nFD,&rfds);

	/* check whether there's decrypted data */
	if(!nrbuf)
	    nrbuf=SSLStateMachine_read_extract(pMachine,rbuf,1);

	/* if there's decrypted data, check whether we can write it */
	if(nrbuf)
	    FD_SET(1,&wfds);

	/* Select socket for output */
	if(SSLStateMachine_write_can_extract(pMachine))
	    FD_SET(nFD,&wfds);

	/* Select stdin for input */
	FD_SET(0,&rfds);

	/* Wait for something to do something */
	n=select(nFD+1,&rfds,&wfds,NULL,NULL);
	assert(n > 0);

	/* Socket is ready for input */
	if(FD_ISSET(nFD,&rfds))
	    {
	    n=read(nFD,buf,sizeof buf);
	    if(n == 0)
		{
		fprintf(stderr,"Got EOF on socket\n");
		exit(0);
		}
	    assert(n > 0);

	    SSLStateMachine_read_inject(pMachine,buf,n);
	    }

	/* stdout is ready for output (and hence we have some to send it) */
	if(FD_ISSET(1,&wfds))
	    {
	    assert(nrbuf == 1);
	    buf[0]=rbuf[0];
	    nrbuf=0;

	    n=SSLStateMachine_read_extract(pMachine,buf+1,sizeof buf-1);
	    if(n < 0)
		{
		SSLStateMachine_print_error(pMachine,"read extract failed");
		break;
		}
	    assert(n >= 0);
	    ++n;
	    if(n > 0) /* FIXME: has to be true now */
		{
		int w;
		
		w=write(1,buf,n);
		/* FIXME: we should push back any unwritten data */
		assert(w == n);
		}
	    }

	/* Socket is ready for output (and therefore we have output to send) */
	if(FD_ISSET(nFD,&wfds))
	    {
	    int w;

	    n=SSLStateMachine_write_extract(pMachine,buf,sizeof buf);
	    assert(n > 0);

	    w=write(nFD,buf,n);
	    /* FIXME: we should push back any unwritten data */
	    assert(w == n);
	    }

	/* Stdin is ready for input */
	if(FD_ISSET(0,&rfds))
	    {
	    n=read(0,buf,sizeof buf);
	    if(n == 0)
		{
		fprintf(stderr,"Got EOF on stdin\n");
		exit(0);
		}
	    assert(n > 0);

	    SSLStateMachine_write_inject(pMachine,buf,n);
	    }
	}
    /* not reached */
    return 0;
    }
Exemple #20
0
int main( int argc, char *argv[] )
{
    self = argv[0];

    srand( getpid() * time( 0 ) );

    int id = -1;

    static struct option long_options[] = {
        {"monitor", 1, 0, 'm'},
        {"help", 0, 0, 'h'},
        {"version", 0, 0, 'v'},
        {0, 0, 0, 0}
    };

    while (1)
    {
        int option_index = 0;

        int c = getopt_long (argc, argv, "m:h:v", long_options, &option_index);
        if (c == -1)
        {
            break;
        }

        switch (c)
        {
        case 'm':
            id = atoi(optarg);
            break;
        case 'h':
        case '?':
            Usage();
            break;
        case 'v':
            std::cout << ZM_VERSION << "\n";
            exit(0);
        default:
            //fprintf( stderr, "?? getopt returned character code 0%o ??\n", c );
            break;
        }
    }

    if (optind < argc)
    {
        fprintf( stderr, "Extraneous options, " );
        while (optind < argc)
            printf ("%s ", argv[optind++]);
        printf ("\n");
        Usage();
    }

    if ( id < 0 )
    {
        fprintf( stderr, "Bogus monitor %d\n", id );
        Usage();
        exit( 0 );
    }

    char log_id_string[16];
    snprintf( log_id_string, sizeof(log_id_string), "m%d", id );

    zmLoadConfig();

    logInit( "zmf" );

    ssedetect();

    Monitor *monitor = Monitor::Load( id, false, Monitor::QUERY );

    if ( !monitor )
    {
        fprintf( stderr, "Can't find monitor with id of %d\n", id );
        exit( -1 );
    }

    char capt_path[PATH_MAX];
    char anal_path[PATH_MAX];
    snprintf( capt_path, sizeof(capt_path), "%s/%d/%%s/%%0%dd-capture.jpg", config.dir_events, monitor->Id(), config.event_image_digits );
    snprintf( anal_path, sizeof(anal_path), "%s/%d/%%s/%%0%dd-analyse.jpg", config.dir_events, monitor->Id(), config.event_image_digits );
    zmSetDefaultTermHandler();
    zmSetDefaultDieHandler();

    sigset_t block_set;
    sigemptyset( &block_set );

    int sd = OpenSocket( monitor->Id() );

    FrameHeader frame_header = { 0, 0, false, 0 };
    //unsigned char *image_data = 0;

    fd_set rfds;

    struct timeval timeout;
    timeout.tv_sec = 1;
    timeout.tv_usec = 0;
    while( 1 )
    {
        struct timeval temp_timeout = timeout;

        FD_ZERO(&rfds);
        FD_SET(sd, &rfds);
        int n_found = select( sd+1, &rfds, NULL, NULL, &temp_timeout );
        if( n_found == 0 )
        {
            Debug( 1, "Select timed out" );
            continue;
        }
        else if ( n_found < 0)
        {
            Error( "Select error: %s", strerror(errno) );
            ReopenSocket( sd, monitor->Id() );
            continue;
        }

        sigprocmask( SIG_BLOCK, &block_set, 0 );

        int n_bytes = read( sd, &frame_header, sizeof(frame_header) );
        if ( n_bytes != sizeof(frame_header) )
        {
            if ( n_bytes < 0 )
            {
                Error( "Can't read frame header: %s", strerror(errno) );
            }
            else if ( n_bytes > 0 )
            {
                Error( "Incomplete read of frame header, %d bytes only", n_bytes );
            }
            else
            {
                Warning( "Socket closed at remote end" );
            }
            ReopenSocket( sd, monitor->Id() );
            continue;
        }
        Debug( 1, "Read frame header, expecting %ld bytes of image", frame_header.image_length );
        static unsigned char image_data[ZM_MAX_IMAGE_SIZE];

        // Read for pipe and loop until bytes expected have been read or an error occurs
        int bytes_read = 0;
        do
        {
            n_bytes = read( sd, image_data+bytes_read, frame_header.image_length-bytes_read );
            if (n_bytes < 0) break; // break on error
            if (n_bytes < (int)frame_header.image_length)
            {
                // print some informational messages
                if (bytes_read == 0)
                {
                    Debug(4,"Image read : Short read %d bytes of %d expected bytes",n_bytes,frame_header.image_length);
                }
                else if (bytes_read+n_bytes == (int)frame_header.image_length)
                {
                    Debug(5,"Image read : Read rest of short read: %d bytes read total of %d bytes",n_bytes,frame_header.image_length);
                }
                else
                {
                    Debug(6,"Image read : continuing, read %d bytes (%d so far)", n_bytes, bytes_read+n_bytes);
                }
            }
            bytes_read+= n_bytes;
        } while (n_bytes>0 && (bytes_read < (ssize_t)frame_header.image_length) );

        // Print errors if there was a problem
        if ( n_bytes < 1 )
        {
            Error( "Only read %d bytes of %d\n", bytes_read, frame_header.image_length);
            if ( n_bytes < 0 )
            {
                Error( "Can't read frame image data: %s", strerror(errno) );
            }
            else
            {
                Warning( "Socket closed at remote end" );
            }
            ReopenSocket( sd, monitor->Id() );
            continue;
        }

        static char subpath[PATH_MAX] = "";
        if ( config.use_deep_storage )
        {
            struct tm *time = localtime( &frame_header.event_time );
            snprintf( subpath, sizeof(subpath), "%02d/%02d/%02d/%02d/%02d/%02d", time->tm_year-100, time->tm_mon+1, time->tm_mday, time->tm_hour, time->tm_min, time->tm_sec );
        }
        else
        {
            snprintf( subpath, sizeof(subpath), "%ld", frame_header.event_id );
        }

        static char path[PATH_MAX] = "";
        snprintf( path, sizeof(path), frame_header.alarm_frame?anal_path:capt_path, subpath, frame_header.frame_id );
        Debug( 1, "Got image, writing to %s", path );

        FILE *fd = 0;
        if ( (fd = fopen( path, "w" )) < 0 )
        {
            Error( "Can't fopen '%s': %s", path, strerror(errno) );
            exit( -1 );
        }
        if ( 0 == fwrite( image_data, frame_header.image_length, 1, fd ) )
        {
            Error( "Can't fwrite image data: %s", strerror(errno) );
            exit( -1 );
        }
        fclose( fd );

        sigprocmask( SIG_UNBLOCK, &block_set, 0 );
    }
    logTerm();
    zmDbClose();
}
Exemple #21
0
void CommStart(PComVar cv, LONG lParam, PTTSet ts)
{
	char ErrMsg[31];
	char Temp[20];
	char uimsg[MAX_UIMSG];

	if (! cv->Open ) {
		return;
	}
	if ( cv->Ready ) {
		return;
	}

	// キャンセルタイマがあれば取り消す。ただし、この時点で WM_TIMER が送られている可能性はある。
	if (*cv->ConnetingTimeout > 0) {
		KillTimer(cv->HWin, IdCancelConnectTimer);
	}

	switch (cv->PortType) {
		case IdTCPIP:
			ErrMsg[0] = 0;
			switch (HIWORD(lParam)) {
				case WSAECONNREFUSED:
					get_lang_msg("MSG_COMM_REFUSE_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Connection refused", ts->UILanguageFile);
					_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, "%s", ts->UIMsg);
					break;
				case WSAENETUNREACH:
					get_lang_msg("MSG_COMM_REACH_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Network cannot be reached", ts->UILanguageFile);
					_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, "%s", ts->UIMsg);
					break;
				case WSAETIMEDOUT:
					get_lang_msg("MSG_COMM_CONNECT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Connection timed out", ts->UILanguageFile);
					_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, "%s", ts->UIMsg);
					break;
				default:
					get_lang_msg("MSG_COMM_TIMEOUT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot connect the host", ts->UILanguageFile);
					_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, "%s", ts->UIMsg);
			}
			if (HIWORD(lParam)>0) {
#ifndef NO_INET6
				/* connect() failed */
				if (cv->res->ai_next != NULL) {
					/* try to connect with other protocol */
					CloseSocket(cv->s);
					for (cv->res = cv->res->ai_next; cv->res; cv->res = cv->res->ai_next) {
						cv->s = OpenSocket(cv);
						if (cv->s == INVALID_SOCKET) {
							CloseSocket(cv->s);
							continue;
						}
						AsyncConnect(cv);
						cv->Ready = FALSE;
						cv->RetryWithOtherProtocol = TRUE; /* retry with other procotol */
						return;
					}
				} else {
					/* trying with all protocol family are failed */
					if (cv->NoMsg==0)
					{
						get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
						MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
					}
					PostMessage(cv->HWin, WM_USER_COMMNOTIFY, 0, FD_CLOSE);
					cv->RetryWithOtherProtocol = FALSE;
					return;
				}
#else
	if (cv->NoMsg==0) {
	  get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
	  MessageBox(cv->HWin, ErrMsg, uimsg, MB_TASKMODAL | MB_ICONEXCLAMATION);
	}
	PostMessage(cv->HWin, WM_USER_COMMNOTIFY, 0, FD_CLOSE);
	return;
#endif /* NO_INET6 */
			}

#ifndef NO_INET6
			/* here is connection established */
			cv->RetryWithOtherProtocol = FALSE;
#endif /* NO_INET6 */
			PWSAAsyncSelect(cv->s,cv->HWin,WM_USER_COMMNOTIFY, FD_READ | FD_OOB | FD_CLOSE);
			TCPIPClosed = FALSE;
			break;

		case IdSerial:
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", READENDNAME, cv->ComPort);
			ReadEnd = CreateEvent(NULL,FALSE,FALSE,Temp);
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", WRITENAME, cv->ComPort);
			memset(&wol,0,sizeof(OVERLAPPED));
			wol.hEvent = CreateEvent(NULL,TRUE,TRUE,Temp);
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", READNAME, cv->ComPort);
			memset(&rol,0,sizeof(OVERLAPPED));
			rol.hEvent = CreateEvent(NULL,TRUE,FALSE,Temp);

			/* create the receiver thread */
			if (_beginthread(CommThread,0,cv) == -1) {
				get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
				get_lang_msg("MSG_TT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Can't create thread", ts->UILanguageFile);
				MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
			}
			break;

		case IdFile:
			cv->RRQ = TRUE;
			break;

		case IdNamedPipe:
			cv->ComPort = 0;
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", READENDNAME, cv->ComPort);
			ReadEnd = CreateEvent(NULL,FALSE,FALSE,Temp);
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", WRITENAME, cv->ComPort);
			memset(&wol,0,sizeof(OVERLAPPED));
			wol.hEvent = CreateEvent(NULL,TRUE,TRUE,Temp);
			_snprintf_s(Temp, sizeof(Temp), _TRUNCATE, "%s%d", READNAME, cv->ComPort);
			memset(&rol,0,sizeof(OVERLAPPED));
			rol.hEvent = CreateEvent(NULL,TRUE,FALSE,Temp);

			/* create the receiver thread */
			if (_beginthread(NamedPipeThread,0,cv) == -1) {
				get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
				get_lang_msg("MSG_TT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Can't create thread", ts->UILanguageFile);
				MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
			}
			break;
	}
	cv->Ready = TRUE;
}
Exemple #22
0
/*
* NET_IP_OpenSocket
*/
static qboolean NET_IP_OpenSocket( socket_t *sock, const netadr_t *address, socket_type_t socktype, qboolean server )
{
    int newsocket;
    const char *proto, *stype;

    assert( sock && !sock->open );
    assert( address );

    if( address->type == NA_IP )
        proto = "IP";
    else if( address->type == NA_IP6 )
        proto = "IPv6";
    else
    {
        NET_SetErrorString( "Invalid address type" );
        return qfalse;
    }

    if( socktype == SOCKET_UDP )
        stype = "UDP";
#ifdef TCP_SUPPORT
    else if( socktype == SOCKET_TCP )
        stype = "TCP";
#endif
    else
    {
        NET_SetErrorString( "Invalid socket type" );
        return qfalse;
    }

    if( NET_IsAnyAddress( address ) )
    {
        Com_Printf( "Opening %s/%s socket: *:%hu\n", stype, proto, NET_GetAddressPort( address ) );
    }
    else
    {
        Com_Printf( "Opening %s/%s socket: %s\n", stype, proto, NET_AddressToString( address ) );
    }

    if( ( newsocket = OpenSocket( socktype, ( address->type == NA_IP6 ? qtrue : qfalse ) ) ) == INVALID_SOCKET )
        return qfalse;

    // make it non-blocking
    if( !NET_SocketMakeNonBlocking( newsocket ) )
    {
        Sys_NET_SocketClose( newsocket );
        return qfalse;
    }

    if( socktype == SOCKET_UDP )
    {
        // make it broadcast capable
        if( !NET_SocketMakeBroadcastCapable( newsocket ) )
        {
            Sys_NET_SocketClose( newsocket );
            return qfalse;
        }
    }

    // wsw : pb : make it reusable (fast release of port when quit)
    /*if( setsockopt(newsocket, SOL_SOCKET, SO_REUSEADDR, (char *)&i, sizeof(i)) == -1 ) {
    SetErrorStringFromErrno( "setsockopt" );
    return 0;
    }*/

    if( !BindSocket( newsocket, address ) )
    {
        Sys_NET_SocketClose( newsocket );
        return qfalse;
    }

    sock->open = qtrue;
    sock->type = socktype;
    sock->address = *address;
    sock->server = server;
    sock->handle = newsocket;

    return qtrue;
}
Exemple #23
0
int ReopenSocket( int &sd, int monitor_id )
{
    close( sd );
    return( sd = OpenSocket( monitor_id ) );
}
Exemple #24
0
int main( int argc, char *argv[] )
{
    srand( getpid() * time( 0 ) );

	int id = -1;

	static struct option long_options[] = {
		{"monitor", 1, 0, 'm'},
		{"help", 0, 0, 'h'},
		{0, 0, 0, 0}
	};

	while (1)
	{
		int option_index = 0;

		int c = getopt_long (argc, argv, "m:h", long_options, &option_index);
		if (c == -1)
		{
			break;
		}

		switch (c)
		{
			case 'm':
				id = atoi(optarg);
				break;
			case 'h':
			case '?':
				Usage();
				break;
			default:
				//fprintf( stderr, "?? getopt returned character code 0%o ??\n", c );
				break;
		}
	}

	if (optind < argc)
	{
		fprintf( stderr, "Extraneous options, " );
		while (optind < argc)
			printf ("%s ", argv[optind++]);
		printf ("\n");
		Usage();
	}

	if ( id < 0 )
	{
		fprintf( stderr, "Bogus monitor %d\n", id );
		Usage();
		exit( 0 );
	}

	char dbg_id_string[16];
	snprintf( dbg_id_string, sizeof(dbg_id_string), "m%d", id );

	zmDbgInit( "zmf", dbg_id_string, 0 );

	zmLoadConfig();

	Monitor *monitor = Monitor::Load( id, false, Monitor::QUERY );

	if ( !monitor )
	{
		fprintf( stderr, "Can't find monitor with id of %d\n", id );
		exit( -1 );
	}

	char capt_path[PATH_MAX];
	char anal_path[PATH_MAX];
	snprintf( capt_path, sizeof(capt_path), "%s/%d/%%s/%%0%dd-capture.jpg", config.dir_events, monitor->Id(), config.event_image_digits );
	snprintf( anal_path, sizeof(anal_path), "%s/%d/%%s/%%0%dd-analyse.jpg", config.dir_events, monitor->Id(), config.event_image_digits );
	zmSetDefaultTermHandler();
	zmSetDefaultDieHandler();

	sigset_t block_set;
	sigemptyset( &block_set );

	int sd = OpenSocket( monitor->Id() );

	FrameHeader frame_header = { 0, 0, false, 0 };
	//unsigned char *image_data = 0;

	fd_set rfds;

	struct timeval timeout;
	timeout.tv_sec = 1;
	timeout.tv_usec = 0;
	while( 1 )
	{
		struct timeval temp_timeout = timeout;

		FD_ZERO(&rfds);
		FD_SET(sd, &rfds);
		int n_found = select( sd+1, &rfds, NULL, NULL, &temp_timeout );
		if( n_found == 0 )
		{
			Debug( 1, "Select timed out" );
			continue;
		}
		else if ( n_found < 0)
		{
			Error( "Select error: %s", strerror(errno) );
			ReopenSocket( sd, monitor->Id() );
			continue;
		}

		sigprocmask( SIG_BLOCK, &block_set, 0 );

		int n_bytes = read( sd, &frame_header, sizeof(frame_header) );
		if ( n_bytes != sizeof(frame_header) )
		{
			if ( n_bytes < 0 )
			{
				Error( "Can't read frame header: %s", strerror(errno) );
			}
			else if ( n_bytes > 0 )
			{
				Error( "Incomplete read of frame header, %d bytes only", n_bytes );
			}
			else
			{
				Warning( "Socket closed at remote end" );
			}
			ReopenSocket( sd, monitor->Id() );
			continue;
		}
		Debug( 1, "Read frame header, expecting %ld bytes of image", frame_header.image_length );
		static unsigned char image_data[ZM_MAX_IMAGE_SIZE];
		n_bytes = read( sd, image_data, frame_header.image_length );
		if ( n_bytes != (ssize_t)frame_header.image_length )
		{
			if ( n_bytes < 0 )
			{
				Error( "Can't read frame image data: %s", strerror(errno) );
			}
			else if ( n_bytes > 0 )
			{
				Error( "Incomplete read of frame image data, %d bytes only", n_bytes );
			}
			else
			{
				Warning( "Socket closed at remote end" );
			}
			ReopenSocket( sd, monitor->Id() );
			continue;
		}
		static char subpath[PATH_MAX] = "";
        if ( config.use_deep_storage )
        {
            struct tm *time = localtime( &frame_header.event_time );
            snprintf( subpath, sizeof(subpath), "%02d/%02d/%02d/%02d/%02d/%02d", time->tm_year-100, time->tm_mon+1, time->tm_mday, time->tm_hour, time->tm_min, time->tm_sec );
        }
        else
        {
            snprintf( subpath, sizeof(subpath), "%ld", frame_header.event_id );
        }
		static char path[PATH_MAX] = "";
		snprintf( path, sizeof(path), frame_header.alarm_frame?anal_path:capt_path, subpath, frame_header.frame_id );
		Debug( 1, "Got image, writing to %s", path );

		FILE *fd = 0;
		if ( (fd = fopen( path, "w" )) < 0 )
		{
			Error( "Can't fopen '%s': %s", path, strerror(errno) );
			exit( -1 );
		}
		if ( 0 == fwrite( image_data, frame_header.image_length, 1, fd ) )
		{
			Error( "Can't fwrite image data: %s", strerror(errno) );
			exit( -1 );
		}
		fclose( fd );

		sigprocmask( SIG_UNBLOCK, &block_set, 0 );
	}
}
Exemple #25
0
int testserver(void) {
    unsigned int sockaddr;
    unsigned char mysocket;
    unsigned int rsize;

    mysocket = 0; // magic number! declare the socket number we will use (0-3)
    sockaddr = 0x400;//W5100_SKT_BASE(mysocket); // calc address of W5100 register set for this socket

    /*
     *  The main loop.  Control stays in this loop forever, processing any received packets
     *  and sending any requested data.
     */
    while (1) {
        LATAbits.LATA0 ^= 1;
        int x = w5100_read(sockaddr + W5100_SR_OFFSET);
        switch (x) // based on current status of socket...
        {
            case W5100_SKT_SR_CLOSED: // if socket is closed...
                LATBbits.LATB8 = 0;
                if (OpenSocket(mysocket, W5100_SKT_MR_TCP, HTTP_PORT) == mysocket) // if successful opening a socket...
                {
                    Listen(mysocket);
                    __delay_ms(1);
                }
                break;

            case W5100_SKT_SR_ESTABLISHED: // if socket connection is established...
                LATBbits.LATB8 = 1;
                rsize = ReceivedSize(mysocket); // find out how many bytes
                if (rsize > 0) {
                    if (Receive(mysocket, buf, rsize) != W5100_OK) break; // if we had problems, all done
                    /*
                     *  Add code here to process the payload from the packet.
                     *
                     *  For now, we just ignore the payload and send a canned HTML page so the client at least
                     *  knows we are alive.
                     */
                    strcpy((char *) buf, "HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nPragma: no-cache\r\n\r\n");
                    strcat((char *) buf, "<html>\r\n<body>\r\n");
                    strcat((char *) buf, "<title>Phil's W5100 web server (ATmega644p)</title>\r\n");
                    strcat((char *) buf, "<h2>Phil's ATmega644p web server using Wiznet W5100 chip</h2>\r\n");
                    strcat((char *) buf, "<br /><hr>\r\n");
                    if (Send(mysocket, buf, strlen((char *) buf)) == W5100_FAIL) break; // just throw out the packet for now

                    strcpy((char *) buf, "This is part 2 of the page.");
                    strcat((char *) buf, "</body>\r\n</html>\r\n");
                    if (Send(mysocket, buf, strlen((char *) buf)) == W5100_FAIL) break; // just throw out the packet for now

                    DisconnectSocket(mysocket);
                } else // no data yet...
                {
                    __delay_us(10);
                }
                break;

            case W5100_SKT_SR_FIN_WAIT:
            case W5100_SKT_SR_CLOSING:
            case W5100_SKT_SR_TIME_WAIT:
            case W5100_SKT_SR_CLOSE_WAIT:
            case W5100_SKT_SR_LAST_ACK:
                CloseSocket(mysocket);
                break;
        }
    }

    return 0;
}
int main(void)
{
	unsigned int sockaddr;
	unsigned char mysocket;
	unsigned int rsize;

	/* Initialize the UART for ATmega168 96008N1    */
	uart_init();

	stdout = &uart_stdout;	//Required for printf init

	mysocket = 0;		// magic number! declare the socket number we will us
	sockaddr = W5100_SKT_BASE(mysocket);	// calc address of W5100 register set for this socket

	puts("AVR Ethernet\r\n");
/*
 *  Initialize the ATmega168 SPI subsystem
 */
	CS_PORT |= (1 << CS_BIT);	// pull CS pin high
	CS_DDR |= (1 << CS_BIT);	// now make it an output

	SPI_PORT = SPI_PORT | (1 << PORTB2);	// make sure SS is high
	SPI_DDR = (1 << PORTB3) | (1 << PORTB5) | (1 << PORTB2);	// set MOSI, SCK and SS as output, others as input
	SPCR = (1 << SPE) | (1 << MSTR);	// enable SPI, master mode 0
	SPSR |= (1 << SPI2X);	// set the clock rate fck/2

/*
 *  Load up the callback block, then initialize the Wiznet W5100
 */
	my_callbacks._select = &my_select;	// callback for selecting the W5100
	my_callbacks._xchg = &my_xchg;	// callback for exchanging data
	my_callbacks._deselect = &my_deselect;	// callback for deselecting the W5100
	my_callbacks._reset = &my_reset;	// callback for hardware-reset of the W5100

	W51_register(&my_callbacks);	// register our target-specific W5100 routines with the W5100 library
	W51_init();		// now initialize the W5100

/*
 *  Configure the W5100 device to handle PING requests.
 *  This requires configuring the chip, not a specific socket.
 */
	W51_config(&my_cfg);	// config the W5100 (MAC, TCP address, subnet, etc

	puts("Debug: AVR Ethernet after W5100 config\r\n");

/*
 *  The main loop.  Control stays in this loop forever, processing any received packets
 *  and sending any requested data.
 */
	while (1) {
		switch (W51_read(sockaddr + W5100_SR_OFFSET))	// based on current status of socket...
		{
		case W5100_SKT_SR_CLOSED:	// if socket is closed...
			if (OpenSocket(mysocket, W5100_SKT_MR_TCP, HTTP_PORT) == mysocket)	// if successful opening a socket...
			{
				Listen(mysocket);
				_delay_ms(1);
			}
			break;

		case W5100_SKT_SR_ESTABLISHED:	// if socket connection is established...
			rsize = ReceivedSize(mysocket);	// find out how many bytes
			if (rsize > 0) {
				if (Receive(mysocket, buf, rsize) != W5100_OK)
					break;	// if we had problems, all done
/*
 *  Add code here to process the payload from the packet.
 *
 *  For now, we just ignore the payload and send a canned HTML page so the client at least
 *  knows we are alive.
 */
				strcpy_P((char *)buf,PSTR("HTTP/1.0 200 OK\r\nContent-Type: text/html\r\nPragma: no-cache\r\n\r\n"));
				strcat_P((char *)buf,PSTR("<html>\r\n<body>\r\n"));
				strcat_P((char *)buf,PSTR("<title>Title</title>\r\n"));
				strcat_P((char *)buf,PSTR("<p>Hello world</p>\r\n"));
				strcat_P((char *)buf,PSTR("</body>\r\n</html>\r\n"));
				if (Send(mysocket, buf, strlen((char *)buf)) == W5100_FAIL) break;	// just throw out the packet for now

				DisconnectSocket(mysocket);
			} else	// no data yet...
			{
				_delay_us(10);
			}
			break;

		case W5100_SKT_SR_FIN_WAIT:
		case W5100_SKT_SR_CLOSING:
		case W5100_SKT_SR_TIME_WAIT:
		case W5100_SKT_SR_CLOSE_WAIT:
		case W5100_SKT_SR_LAST_ACK:
			CloseSocket(mysocket);
			break;
		}
	}

	return 0;
}
Exemple #27
0
I2Addr
CreateListenSocket(I2Addr addr, char* serv, int options, int buf_size)
{
  int fd = -1;
  socklen_t optlen;
  int set_size;

  if (addr && (I2AddrFD(addr) > -1)) {
    log_println(1, "Invalid I2Addr record - fd already specified.");
    goto error;
  }

  if ((!addr) && !(addr = I2AddrByWildcard(get_errhandle(), SOCK_STREAM, serv))) {
    log_println(1, "Unable to create I2Addr record by wildcard.");
    goto error;
  }

  if (!I2AddrSetPassive(addr,True)) {
    log_println(1, "Unable to set passive mode in I2Addr record.");
    goto error;
  }
  
  fd = OpenSocket(addr, serv, options);
  
  if (fd < 0) {
    log_println(1, "Unable to open socket.");
    goto error;
  }

/* Set sock opt code from Marion Nakanson <[email protected]
 *  OHSU Advanced Computing Center
 * email on 2/19/09 correctly notes that setsockops must be made before open()
 * or listen() calls are made
 */

  optlen = sizeof(set_size);
  getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &set_size, &optlen);
  log_print(5, "\nSend buffer initialized to %d, ", set_size);
  getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &set_size, &optlen);
  log_println(5, "Receive buffer initialized to %d", set_size);
  if (buf_size > 0) {
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));
    setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
    getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &set_size, &optlen);
    log_print(5, "Changed buffer sizes: Send buffer set to %d(%d), ", set_size, buf_size);
    getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &set_size, &optlen);
    log_println(5, "Receive buffer set to %d(%d)", set_size, buf_size);
  }


  if (listen(fd, NDT_BACKLOG) < 0) {
    log_println(1, "listen(%d,%d):%s", fd, NDT_BACKLOG, strerror(errno));
    goto error;
  }

  return addr;
  
error:
    I2AddrFree(addr);
    return NULL;
}
Exemple #28
0
void CommOpen(HWND HW, PTTSet ts, PComVar cv)
{
#ifdef NO_INET6
	int Err;
#endif /* NO_INET6 */
	char ErrMsg[21+256];
	char P[50+256];

	MSG Msg;
#ifndef NO_INET6
	ADDRINFO hints;
	char pname[NI_MAXSERV];
#else
	char HEntBuff[MAXGETHOSTSTRUCT];
	u_long addr;
	SOCKADDR_IN saddr;
#endif /* NO_INET6 */

	BOOL InvalidHost;
#ifdef NO_INET6
	BOOL BBuf;
#endif /* NO_INET6 */

	char uimsg[MAX_UIMSG];

	// ホスト名が名前付きパイプかどうかを調べる。
	if (ts->PortType == IdTCPIP) {
		if (CheckNamedPipeFormat(ts->HostName, strlen(ts->HostName)) == 0) {
			ts->PortType = IdNamedPipe;
		}
	}

	/* initialize ComVar */
	cv->InBuffCount = 0;
	cv->InPtr = 0;
	cv->OutBuffCount = 0;
	cv->OutPtr = 0;
	cv->HWin = HW;
	cv->Ready = FALSE;
	cv->Open = FALSE;
	cv->PortType = ts->PortType;
	cv->ComPort = 0;
	cv->RetryCount = 0;
#ifndef NO_INET6
	cv->RetryWithOtherProtocol = TRUE;
#endif /* NO_INET6 */
	cv->s = INVALID_SOCKET;
	cv->ComID = INVALID_HANDLE_VALUE;
	cv->CanSend = TRUE;
	cv->RRQ = FALSE;
	cv->SendKanjiFlag = FALSE;
	cv->SendCode = IdASCII;
	cv->EchoKanjiFlag = FALSE;
	cv->EchoCode = IdASCII;
	cv->Language = ts->Language;
	cv->CRSend = ts->CRSend;
	cv->KanjiCodeEcho = ts->KanjiCode;
	cv->JIS7KatakanaEcho = ts->JIS7Katakana;
	cv->KanjiCodeSend = ts->KanjiCodeSend;
	cv->JIS7KatakanaSend = ts->JIS7KatakanaSend;
	cv->KanjiIn = ts->KanjiIn;
	cv->KanjiOut = ts->KanjiOut;
	cv->RussHost = ts->RussHost;
	cv->RussClient = ts->RussClient;
	cv->DelayFlag = TRUE;
	cv->DelayPerChar = ts->DelayPerChar;
	cv->DelayPerLine = ts->DelayPerLine;
	cv->TelBinRecv = FALSE;
	cv->TelBinSend = FALSE;
	cv->TelFlag = FALSE;
	cv->TelMode = FALSE;
	cv->IACFlag = FALSE;
	cv->TelCRFlag = FALSE;
	cv->TelCRSend = FALSE;
	cv->TelCRSendEcho = FALSE;
	cv->TelAutoDetect = ts->TelAutoDetect; /* TTPLUG */
	cv->Locale = ts->Locale;
	cv->locale = _create_locale(LC_ALL, cv->Locale);
	cv->CodePage = &ts->CodePage;
	cv->ConnetingTimeout = &ts->ConnectingTimeout;
	cv->LastSendTime = time(NULL);
	cv->LineModeBuffCount = 0;
	cv->Flush = FALSE;
	cv->FlushLen = 0;
	cv->TelLineMode = FALSE;

	if ((ts->PortType!=IdSerial) && (strlen(ts->HostName)==0))
	{
		PostMessage(cv->HWin, WM_USER_COMMNOTIFY, 0, FD_CLOSE);
		return;
	}

	switch (ts->PortType) {
		case IdTCPIP:
			cv->TelFlag = (ts->Telnet > 0);
			if (ts->EnableLineMode) {
				cv->TelLineMode = TRUE;
			}
			if (! LoadWinsock()) {
				if (cv->NoMsg==0) {
					get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
					get_lang_msg("MSG_WINSOCK_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot use winsock", ts->UILanguageFile);
					MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				}
				InvalidHost = TRUE;
			}
			else {
				TTXOpenTCP(); /* TTPLUG */
				cv->Open = TRUE;
#ifndef NO_INET6
				/* resolving address */
				memset(&hints, 0, sizeof(hints));
				hints.ai_family = ts->ProtocolFamily;
				hints.ai_socktype = SOCK_STREAM;
				hints.ai_protocol = IPPROTO_TCP;
				_snprintf_s(pname, sizeof(pname), _TRUNCATE, "%d", ts->TCPPort);

				HAsync = PWSAAsyncGetAddrInfo(HW, WM_USER_GETHOST,
				                             ts->HostName, pname, &hints, &cv->res0);
				if (HAsync == 0)
					InvalidHost = TRUE;
				else {
					cv->ComPort = 1; // set "getting host" flag
					                 //  (see CVTWindow::OnSysCommand())
					do {
						if (GetMessage(&Msg,0,0,0)) {
							if ((Msg.hwnd==HW) &&
							    ((Msg.message == WM_SYSCOMMAND) &&
							     ((Msg.wParam & 0xfff0) == SC_CLOSE) ||
							     (Msg.message == WM_COMMAND) &&
							     (LOWORD(Msg.wParam) == ID_FILE_EXIT) ||
							     (Msg.message == WM_CLOSE))) { /* Exit when the user closes Tera Term */
								PWSACancelAsyncRequest(HAsync);
								CloseHandle(HAsync);
								HAsync = 0;
								cv->ComPort = 0; // clear "getting host" flag
								PostMessage(HW,Msg.message,Msg.wParam,Msg.lParam);
								return;
							}
							if (Msg.message != WM_USER_GETHOST) { /* Prosess messages */
								TranslateMessage(&Msg);
								DispatchMessage(&Msg);
							}
						}
						else {
							return;
						}
					} while (Msg.message!=WM_USER_GETHOST);
					cv->ComPort = 0; // clear "getting host" flag
					CloseHandle(HAsync);
					HAsync = 0;
					InvalidHost = WSAGETASYNCERROR(Msg.lParam) != 0;
				}
			} /* if (!LoadWinsock()) */

			if (InvalidHost) {
				if (cv->NoMsg==0) {
					get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
					get_lang_msg("MSG_INVALID_HOST_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Invalid host", ts->UILanguageFile);
					MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				}
				goto BreakSC;
			}
			for (cv->res = cv->res0; cv->res; cv->res = cv->res->ai_next) {
				cv->s =  OpenSocket(cv);
				if (cv->s == INVALID_SOCKET) {
					CloseSocket(cv->s);
					continue;
				}
				/* start asynchronous connect */
				AsyncConnect(cv);
				break; /* break for-loop immediately */
			}
			break;
#else
	if ((ts->HostName[0] >= 0x30) && (ts->HostName[0] <= 0x39))
	{
	  addr = Pinet_addr(ts->HostName);
	  InvalidHost = (addr == 0xffffffff);
	}
	else {
	  HAsync = PWSAAsyncGetHostByName(HW,WM_USER_GETHOST,
	  ts->HostName,HEntBuff,sizeof(HEntBuff));
	  if (HAsync == 0)
	    InvalidHost = TRUE;
	  else {
	    cv->ComPort = 1; // set "getting host" flag
			     //  (see CVTWindow::OnSysCommand())
	    do {
	      if (GetMessage(&Msg,0,0,0))
	      {
		if ((Msg.hwnd==HW) &&
		    ((Msg.message == WM_SYSCOMMAND) &&
		     ((Msg.wParam & 0xfff0) == SC_CLOSE) ||
		     (Msg.message == WM_COMMAND) &&
		     (LOWORD(Msg.wParam) == ID_FILE_EXIT) ||
		     (Msg.message == WM_CLOSE)))
		{ /* Exit when the user closes Tera Term */
		  PWSACancelAsyncRequest(HAsync);
		  HAsync = 0;
		  cv->ComPort = 0; // clear "getting host" flag
		  PostMessage(HW,Msg.message,Msg.wParam,Msg.lParam);
		  return;
		}
		if (Msg.message != WM_USER_GETHOST)
		{ /* Prosess messages */
		  TranslateMessage(&Msg);
		  DispatchMessage(&Msg);
		}
	      }
	      else {
		return;
	      }
	    } while (Msg.message!=WM_USER_GETHOST);
	    cv->ComPort = 0; // clear "getting host" flag
	    HAsync = 0;
	    InvalidHost = WSAGETASYNCERROR(Msg.lParam) != 0;
	    if (! InvalidHost)
	    {
	      if (((PHOSTENT)HEntBuff)->h_addr_list != NULL)
		memcpy(&addr,
		  ((PHOSTENT)HEntBuff)->h_addr_list[0],sizeof(addr));
	      else
		InvalidHost = TRUE;
	    }
	  }

	}

	if (InvalidHost)
	{
	  if (cv->NoMsg==0) {
	    get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
	    get_lang_msg("MSG_INVALID_HOST_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Invalid host", ts->UILanguageFile);
	    MessageBox(cv->HWin, ts->UIMsg, uimsg, MB_TASKMODAL | MB_ICONEXCLAMATION);
	  }
	}
	else {
	  cv->s= Psocket(AF_INET,SOCK_STREAM,IPPROTO_TCP);
	  if (cv->s==INVALID_SOCKET)
	  {
	    InvalidHost = TRUE;
	    if (cv->NoMsg==0) {
	      get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
	      get_lang_msg("MSG_COMM_TIMEOUT_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot connect the host", ts->UILanguageFile);
	      MessageBox(cv->HWin, ts->UIMsg, uimsg, MB_TASKMODAL | MB_ICONEXCLAMATION);
	    }
	  }
	  else {
	    BBuf = TRUE;
	    Psetsockopt(cv->s,(int)SOL_SOCKET,SO_OOBINLINE,(char FAR *)&BBuf,sizeof(BBuf));

	    PWSAAsyncSelect(cv->s,cv->HWin,WM_USER_COMMOPEN, FD_CONNECT);
	    saddr.sin_family = AF_INET;
	    saddr.sin_port = Phtons(ts->TCPPort);
	    saddr.sin_addr.s_addr = addr;
	    memset(saddr.sin_zero,0,8);

	    Err = Pconnect(cv->s,(LPSOCKADDR)&saddr,sizeof(saddr));
	    if (Err!=0 ) Err = PWSAGetLastError();
	    if (Err==WSAEWOULDBLOCK )
	    {
	      /* Do nothing */
	    }
	    else if (Err!=0 )
	      PostMessage(cv->HWin, WM_USER_COMMOPEN,0,
			  MAKELONG(FD_CONNECT,Err));
	  }
	}
      }
      break;
#endif /* NO_INET6 */

		case IdSerial:
			InitFileIO(IdSerial);  /* TTPLUG */
			TTXOpenFile(); /* TTPLUG */
			_snprintf_s(P, sizeof(P), _TRUNCATE, "COM%d", ts->ComPort);
			strncpy_s(ErrMsg, sizeof(ErrMsg),P, _TRUNCATE);
			strncpy_s(P, sizeof(P),"\\\\.\\", _TRUNCATE);
			strncat_s(P, sizeof(P),ErrMsg, _TRUNCATE);
			cv->ComID =
			PCreateFile(P,GENERIC_READ | GENERIC_WRITE,
			            0,NULL,OPEN_EXISTING,
			            FILE_FLAG_OVERLAPPED,NULL);
			if (cv->ComID == INVALID_HANDLE_VALUE ) {
				get_lang_msg("MSG_CANTOEPN_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open %s", ts->UILanguageFile);
				_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, ts->UIMsg, &P[4]);

				if (cv->NoMsg==0) {
					get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
					MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				}
				InvalidHost = TRUE;
			}
			else {
				cv->Open = TRUE;
				cv->ComPort = ts->ComPort;
				CommResetSerial(ts, cv, ts->ClearComBuffOnOpen);
				if (!ts->ClearComBuffOnOpen) {
					cv->RRQ = TRUE;
				}

				/* notify to VT window that Comm Port is open */
				PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
				InvalidHost = FALSE;

				SetCOMFlag(ts->ComPort);
			}
			break; /* end of "case IdSerial:" */

		case IdFile:
			InitFileIO(IdFile);  /* TTPLUG */
			TTXOpenFile(); /* TTPLUG */
			cv->ComID = PCreateFile(ts->HostName,GENERIC_READ,0,NULL,
			                        OPEN_EXISTING,0,NULL);
			InvalidHost = (cv->ComID == INVALID_HANDLE_VALUE);
			if (InvalidHost) {
				if (cv->NoMsg==0) {
					get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
					get_lang_msg("MSG_CANTOEPN_FILE_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open file", ts->UILanguageFile);
					MessageBox(cv->HWin,ts->UIMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				}
			}
			else {
				cv->Open = TRUE;
				PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
			}
			break;

		case IdNamedPipe:
			InitFileIO(IdNamedPipe);  /* TTPLUG */
			TTXOpenFile(); /* TTPLUG */
			
			memset(P, 0, sizeof(P));
			strncpy_s(P, sizeof(P), ts->HostName, _TRUNCATE);

			// 名前付きパイプが正しい書式かをチェックする。
			if (CheckNamedPipeFormat(P, strlen(P)) < 0) {
				InvalidHost = TRUE;

				_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, 
					"Invalid pipe name\n\n"
					"A valid pipe name has the form\n"
					"\"\\\\<ServerName>\\pipe\\<PipeName>\"", 
					GetLastError());
				get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
				MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				break;
			}

			cv->ComID =
			PCreateFile(P,GENERIC_READ | GENERIC_WRITE,
			            0,NULL,OPEN_EXISTING,
			            0,  // ブロッキングモードにする(FILE_FLAG_OVERLAPPED は指定しない)
						NULL);
			if (cv->ComID == INVALID_HANDLE_VALUE ) {
				get_lang_msg("MSG_CANTOEPN_ERROR", ts->UIMsg, sizeof(ts->UIMsg), "Cannot open %s", ts->UILanguageFile);
				_snprintf_s(ErrMsg, sizeof(ErrMsg), _TRUNCATE, ts->UIMsg, &P[4]);

				if (cv->NoMsg==0) {
					get_lang_msg("MSG_TT_ERROR", uimsg, sizeof(uimsg), "Tera Term: Error", ts->UILanguageFile);
					MessageBox(cv->HWin,ErrMsg,uimsg,MB_TASKMODAL | MB_ICONEXCLAMATION);
				}
				InvalidHost = TRUE;
			}
			else {
				cv->Open = TRUE;
				PostMessage(cv->HWin, WM_USER_COMMOPEN, 0, 0);
				InvalidHost = FALSE;
			}
			break; /* end of "case IdNamedPipe:" */

	} /* end of "switch" */
Exemple #29
0
I2Addr CreateListenSocket(I2Addr addr, char* serv, int options, int buf_size) {
  int fd = -1;
  socklen_t optlen;
  int set_size;

  if (addr && (I2AddrFD(addr) > -1)) {
    log_println(1, "Invalid I2Addr record - fd already specified.");
    goto error;
  }

  if ((!addr) &&
      !(addr = I2AddrByWildcard(get_errhandle(), SOCK_STREAM, serv))) {
    log_println(1, "Unable to create I2Addr record by wildcard.");
    goto error;
  }

  if (!I2AddrSetPassive(addr, True)) {
    log_println(1, "Unable to set passive mode in I2Addr record.");
    goto error;
  }

  // create and bind socket using arguments, prefering v6 (since v6 addresses
  // can be both v4 and v6).
#ifdef AF_INET6
  if ((options & OPT_IPV4_ONLY) == 0)
    fd = OpenSocket(addr, serv, AF_INET6, options);
#endif
  if (fd < 0)
    if ((options & OPT_IPV6_ONLY) == 0)
      fd = OpenSocket(addr, serv, AF_INET, options);

  if (fd < 0) {
    log_println(1, "Unable to open socket.");
    goto error;
  }

  /* Set sock opt code from Marion Nakanson <[email protected]
   *  OHSU Advanced Computing Center
   * email on 2/19/09 correctly notes that setsockops must be made before open()
   * or listen() calls are made
   */

  optlen = sizeof(set_size);
  // get send buffer size
  getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &set_size, &optlen);
  log_print(5, "\nSend buffer initialized to %d, ", set_size);

  // get receive buffer size
  getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &set_size, &optlen);
  log_println(5, "Receive buffer initialized to %d", set_size);

  // now assign buffer sizes passed as arguments
  if (buf_size > 0) {
    setsockopt(fd, SOL_SOCKET, SO_SNDBUF, &buf_size, sizeof(buf_size));
    setsockopt(fd, SOL_SOCKET, SO_RCVBUF, &buf_size, sizeof(buf_size));
    // print values set to help user verify
    getsockopt(fd, SOL_SOCKET, SO_SNDBUF, &set_size, &optlen);
    log_print(5, "Changed buffer sizes: Send buffer set to %d(%d), ",
              set_size, buf_size);
    getsockopt(fd, SOL_SOCKET, SO_RCVBUF, &set_size, &optlen);
    log_println(5, "Receive buffer set to %d(%d)", set_size, buf_size);
  }

  // listen on socket for connections, with backlog queue length = NDT_BACKLOG
  if (listen(fd, NDT_BACKLOG) < 0) {  // if listen returns value <0, then error
    log_println(1, "listen(%d,%d):%s", fd, NDT_BACKLOG, strerror(errno));
    goto error;
  }

  return addr;

  // If error, try freeing memory
 error:
  I2AddrFree(addr);
  return NULL;
}
void CTcpSymbianEngine::OpenSocketL()
{
   User::LeaveIfError(OpenSocket());
}