Exemplo n.º 1
0
/**
 * @brief	This function processes the delete port to IGD(Internet Gateway Device).
 * @return	0: success, -2: Invalid UPnP Step, -1: reply packet timeout, 1: received xml parse error, other: UPnP error code
 */
signed short DeletePortProcess(
  SOCKET sockfd,	/**< a socket number. */
  const char* protocol,	/**< a procotol name. "TCP" or "UDP" */
  const unsigned int extertnal_port	/**< an external port number. */
  )
{
	short len=0;
	long endTime=0;
	uint32 ipaddr;
	uint16 port;

	// Check UPnP Step
	if(UPnP_Step < 2) return -2;

	// Make "Delete Port" XML(SOAP)
	memset(content, '\0', MAX_BUFFER);
	MakeSOAPDeleteControl(content, protocol, extertnal_port);

	// Make HTTP POST Header
	memset(send_buffer, '\0', MAX_BUFFER);
	len = strlen(content);
	MakePOSTHeader(send_buffer, len, DELETE_PORT);
	strcat(send_buffer, content);

#ifdef UPNP_DEBUG
	printf("%s\r\n", send_buffer);
#endif

        ipaddr = inet_addr((uint8*)descIP);
        ipaddr = swapl(ipaddr);
        port = ATOI(descPORT, 10);

	// Connect to IGD(Internet Gateway Device)
	if(TCPClientOpen(sockfd, PORT_UPNP, (uint8*)&ipaddr, port) == FAIL) printf("TCP Socket Error!!\r\n");

	// Send "Delete Port" Message
	while(GetTCPSocketStatus(sockfd) != STATUS_ESTABLISHED);
	TCPSend(sockfd, (void *)send_buffer, strlen(send_buffer));

	// Receive Reply
	memset(recv_buffer, '\0', MAX_BUFFER);
	Delay_ms(500);
	endTime = my_time + 3;
	while (TCPRecv(sockfd, (void *)recv_buffer, MAX_BUFFER) <= 0 && my_time < endTime);	// Check Receive Buffer of W5200
	if(my_time >= endTime){	// Check Timeout
		TCPClose(sockfd);
		return -1;
	}

	// TCP Socket Close
        TCPClose(sockfd);

#ifdef UPNP_DEBUG
	printf("\r\nReceiveData\r\n%s\r\n", recv_buffer);
#endif

	// Parse Replied Message
	return parseDeletePort(recv_buffer);
}
Exemplo n.º 2
0
Arquivo: ftp.c Projeto: KISSMonX/W7200
void Send_cmd(uint8 sock, char* msg)
{
	uint16	len;
	char	new_msg[STR_SIZE];
	char    dat[STR_SIZE];


	if( strstr(msg,"ls") != NULL )
	{
		TCPSend(sock,ls,strlen(ls));
	}
	else if( strstr(msg,"get") != NULL )
	{
		memset(dat, 0, sizeof(dat));
		memset(new_msg, 0, sizeof(new_msg));
		memcpy(new_msg, msg+4, strlen(msg+4));
		len = sprintf(dat, "RETR %s\r\n",new_msg);
		TCPSend(sock, (uint8*)dat, len);
		
	}
	else if( strstr(msg, "put") != NULL )
	{
		memset(dat, 0, sizeof(dat));
		memset(new_msg, 0, sizeof(new_msg));
		memcpy(new_msg, msg+4, strlen(msg+4));
		len = sprintf(dat, "STOR %s\r\n",new_msg);
		TCPSend(sock, (uint8*)dat, len);
                bRunPutFile = 1;
                
	}
	else if( strstr(msg, "cd") != NULL )
	{
		memset(dat, 0, sizeof(dat));
		memset(new_msg, 0, sizeof(new_msg));
		memcpy(new_msg, msg+3, strlen(msg+3));
		len = sprintf(dat, "CWD %s\r\n", new_msg);
		TCPSend(sock, (uint8*)dat, len);
	}
	else if( strstr(msg, "bye") != NULL )
	{
		TCPSend(sock, bye, strlen(bye) );
		TCPClose(FTP_CLIENT_DTP_SOCK);
		TCPClose(FTP_CLIENT_PI_SOCK);
		JumpAddress = *(volatile unsigned long*) (ApplicationAddress + 4);
		Jump_To_Application = (pFunction) JumpAddress;
		Jump_To_Application();
		while(1);
	}
	else
	{
		printf("\r\n Sorry, this FTP client only support ls, put and get commands!");
		TCPClose(FTP_CLIENT_DTP_SOCK);
		Send_Port(sock, IP, DTP_Port);
	}
}
Exemplo n.º 3
0
/**
 * @brief	This function gets the description message from IGD(Internet Gateway Device).
 * @return	0: success, -2: Invalid UPnP Step, -1: reply packet timeout, 1: received xml parse error
 */
signed char GetDescriptionProcess(
  SOCKET sockfd 	/**< a socket number. */
  )
{
	char ret_value=0;
        long endTime=0;
        uint32 ipaddr;
        uint16 port;

	// Check UPnP Step
	if(UPnP_Step < 1) return -2;

	// Make HTTP GET Header
	memset(send_buffer, '\0', MAX_BUFFER);
	MakeGETHeader(send_buffer);

#ifdef UPNP_DEBUG
	printf("%s\r\n", send_buffer);
#endif

        ipaddr = inet_addr((uint8*)descIP);
        ipaddr = swapl(ipaddr);
        port = ATOI(descPORT, 10);

	// Connect to IGD(Internet Gateway Device)
	if(TCPClientOpen(sockfd, PORT_UPNP, (uint8*)&ipaddr, port) == FAIL) printf("TCP Socket Error!!\r\n");

	// Send Get Discription Message
	while(GetTCPSocketStatus(sockfd) != STATUS_ESTABLISHED);
	TCPSend(sockfd, (void *)send_buffer, strlen(send_buffer));

	// Receive Reply
	memset(recv_buffer, '\0', MAX_BUFFER);
	Delay_ms(500);
	endTime = my_time + 3;
	while (TCPRecv(sockfd, (void *)recv_buffer, MAX_BUFFER) <= 0 && my_time < endTime);	// Check Receive Buffer of W5200
	if(my_time >= endTime){	// Check Timeout
		TCPClose(sockfd);
		return -1;
	}

	// TCP Socket Close
	TCPClose(sockfd);

#ifdef UPNP_DEBUG
	printf("\r\nReceiveData\r\n%s\r\n", recv_buffer);
#endif

	// Parse Discription Message
	if((ret_value = parseDescription(recv_buffer)) == 0) UPnP_Step = 2;
	return ret_value;
}
Exemplo n.º 4
0
/*
 * FUNCTION: Closes an address file object
 * ARGUMENTS:
 *     Request = Pointer to TDI request structure for this request
 * RETURNS:
 *     Status of operation
 */
NTSTATUS FileCloseAddress(
  PTDI_REQUEST Request)
{
  PADDRESS_FILE AddrFile = Request->Handle.AddressHandle;
  KIRQL OldIrql;

  if (!Request->Handle.AddressHandle) return STATUS_INVALID_PARAMETER;

  LockObject(AddrFile, &OldIrql);

  if (InterlockedDecrement(&AddrFile->Sharers) != 0)
  {
      /* Still other guys have open handles to this, so keep it around */
      UnlockObject(AddrFile, OldIrql);
      return STATUS_SUCCESS;
  }

  /* We have to close this listener because we started it */
  if( AddrFile->Listener )
  {
      TCPClose( AddrFile->Listener );
  }

  UnlockObject(AddrFile, OldIrql);

  DereferenceObject(AddrFile);

  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));

  return STATUS_SUCCESS;
}
Exemplo n.º 5
0
void loopback_udp(uint8 ch, uint16 port)
{
    int ret;
    uint32 destip = 0;
    uint16 destport;

    ret = UDPRecv(ch, data_buf, TX_RX_MAX_BUF_SIZE, (uint8*)&destip, &destport);

    if(ret > 0) {				// Received
        ret = UDPSend(ch, data_buf, ret, (uint8*)&destip ,destport);

        if(ret == ERROR_TIME_OUT) {
            ERR("Timeout");
            UDPClose(ch);
            DBG("UDP Socket Close");
        }

    } else if(ret == ERROR_NOT_UDP_SOCKET) {	// Not UDP Socket, It's TCP Socket
        DBG("TCP Socket Close");
        TCPClose(ch);
    } else if(ret == ERROR_CLOSED) {		// Socket Closed
        LOGA("UDP Loop-Back Started - ch(%d)",(uint16)ch);
        UDPOpen(ch, port);
    }
}
Exemplo n.º 6
0
/*
 * Checks the file request response.
 */
BOOL PeerFileAccept (Connection *peer, UWORD ackstatus, UDWORD port)
{
    Connection *flist, *fpeer;
    
    flist = PeerFileCreate (peer->serv);
    fpeer = ServerFindChild (flist->serv, peer->cont, TYPE_FILEDIRECT);
    
    if (!flist || !fpeer || !port || (ackstatus == TCP_ACK_REFUSE))
    {
        if (fpeer)
            TCPClose (fpeer);

        return 0;
    }

    ASSERT_MSGDIRECT(peer);
    ASSERT_FILELISTEN(flist);
    ASSERT_FILEDIRECT(fpeer);
    
    fpeer->connect  = 0;
    fpeer->oscar_dc_seq  = 0;
    fpeer->port     = port;
    fpeer->ip       = peer->ip;
    s_repl (&fpeer->server, s_ip (fpeer->ip));
    
    if (prG->verbose)
        rl_printf (i18n (2520, "Opening file transfer connection to %s:%s%ld%s... \n"),
                  s_wordquote (fpeer->server), COLQUOTE, UD2UL (fpeer->port), COLNONE);

    TCPDispatchConn (fpeer);
    
    return 1;
}
Exemplo n.º 7
0
/*****************************************************************************
  Function:
	uint16_t SMTPEndUsage(void)

  Summary:
	Releases control of the SMTP client module.

  Description:
	Call this function to release control of the SMTP client module once
	an application is finished using it.  This function releases the lock
	obtained by SMTPBeginUsage, and frees the SMTP client to be used by
	another application.

  Precondition:
	SMTPBeginUsage returned true on a previous call.

  Parameters:
	None

  Return Values:
	SMTP_SUCCESS - A message was successfully sent
	SMTP_RESOLVE_ERROR - The SMTP server could not be resolved
	SMTP_CONNECT_ERROR - The connection to the SMTP server failed or was
		prematurely terminated
	1-199 and 300-399 - The last SMTP server response code
  ***************************************************************************/
uint16_t SMTPEndUsage(void)
{
    if(!SMTPFlags.bits.SMTPInUse)
        return 0xFFFF;

    // Release the DNS module, if in use
    if(TransportState == TRANSPORT_NAME_RESOLVE)
        DNSEndUsage(0);

    // Release the TCP socket, if in use
    if(MySocket != INVALID_SOCKET)
    {
        TCPClose(MySocket);
        MySocket = INVALID_SOCKET;
    }

    // Release the SMTP module
    SMTPFlags.bits.SMTPInUse = false;
    TransportState = TRANSPORT_HOME;

    if(SMTPFlags.bits.SentSuccessfully)
    {
        return 0;
    }
    else
    {
        return ResponseCode;
    }
}
Exemplo n.º 8
0
/* ******************************************* */
TINT  SBAErrRet(TSOCK Sock, TINT nErr)
{
	if ( Sock > 0 )
		TCPClose(Sock);

	return nErr;
}
Exemplo n.º 9
0
/* ******************************************* */
TINT  SBAErrRecv(TSOCK Sock)
{
	char  szBuf[CONST_BUF];
	TINT  nLen;

	if ( Sock > 0 )
	{
		if ( !TCPRecvData(Sock, szBuf, &nLen) )
		{
			TCPClose(Sock);
			return ERT_RECV_DATA;
		}
		szBuf[nLen] = 0x00;
		nLen = atoi(szBuf);

		TCPClose(Sock);
	}
	
	return nLen;
}
Exemplo n.º 10
0
void loopback_tcps(uint8 ch, uint16 port)
{
    int ret;
    int SendLen, ReSendLen;

    ret = TCPRecv(ch, data_buf, TX_RX_MAX_BUF_SIZE);

    if(ret > 0) {				// Received
        SendLen = TCPSend(ch, data_buf, ret);

        if(SendLen < ret) {
            while(SendLen != ret) {
                ReSendLen = TCPReSend(ch);

                if(ReSendLen > 0) {
                    SendLen += ReSendLen;

                } else if(ReSendLen == ERROR_WINDOW_FULL) {
                    LOG("Window Full");
                    TCPClose(ch);
                    DBG("TCP Socket Close");
                    while(1);

                } else {
                    break;
                }
            }
        }

    } else if(ret == ERROR_NOT_TCP_SOCKET) {	// Not TCP Socket, It's UDP Socket
        DBG("UDP Socket Close");
        UDPClose(ch);
    } else if(ret == ERROR_CLOSED) {		// Socket Closed
        LOGA("TCP Loop-Back Started - ch(%d)",(uint16)ch);
        TCPServerOpen(ch, port);
    }

    if(GetTCPSocketStatus(ch) == STATUS_CLOSE_WAIT) {	// Close waiting
        TCPClose(ch);
    }
}
Exemplo n.º 11
0
/**
@brief	This Socket function open TCP server socket.
@return 	1 - success, 0 - fail.
*/
int8 TCPServerOpen(SOCKET s, uint16 port)
{
    uint8 ret;
#ifdef __DEF_IINCHIP_DBG__
    printf("TCPServerOpen()\r\n");
#endif

    TCPClose(s);
    IINCHIP_WRITE(Sn_MR(s),Sn_MR_TCP);
    if (port != 0) {
        IINCHIP_WRITE(Sn_PORT0(s),(uint8)((port & 0xff00) >> 8));
        IINCHIP_WRITE((Sn_PORT0(s) + 1),(uint8)(port & 0x00ff));
    } else {
Exemplo n.º 12
0
/*****************************************************************************
  Function:
	static BOOL HandlePossibleTCPDisconnection(SOCKET s)
	
  Summary:
	Internal function that checks for asynchronous TCP connection state 
	changes and resynchs the BSD socket descriptor state to match. 

  Description:
	Internal function that checks for asynchronous TCP connection state 
	changes and resynchs the BSD socket descriptor state to match. 

  Precondition:
	None

  Parameters:
	s - TCP type socket descriptor returned from a previous call to socket.  
	    This socket must be in the SKT_LISTEN, SKT_IN_PROGRESS, SKT_EST, or 
	    SKT_DISCONNECTED states.

  Returns:
	TRUE - Socket is disconnected
	FALSE - Socket is 

  ***************************************************************************/
static BOOL HandlePossibleTCPDisconnection(SOCKET s)
{
	struct BSDSocket *socket;
	BYTE i;
	BOOL bSocketWasReset;

	socket = &BSDSocketArray[s];

	// Nothing to do if disconnection has already been handled
	if(socket->bsdState == SKT_DISCONNECTED)
		return TRUE;	

	// Find out if a disconnect has occurred
	bSocketWasReset = TCPWasReset(socket->SocketID);

	// For server sockets, if the parent listening socket is still open, 
	// then return this socket to the queue for future backlog processing.
	if(socket->isServer)
	{
		for(i = 0; i < sizeof(BSDSocketArray)/sizeof(BSDSocketArray[0]); i++)
		{
			if(BSDSocketArray[i].bsdState != SKT_BSD_LISTEN)
				continue;
			if(BSDSocketArray[i].localPort == socket->localPort)
			{
				// Nothing to do if a disconnect has not occurred
				if(!bSocketWasReset)
					return FALSE;

				// Listener socket is still open, so just return to the 
				// listening state so that the user must call accept() again to 
				// reuse this BSD socket
				socket->bsdState = SKT_LISTEN;
				return TRUE;
			}
		}
	}
			
	// If we get down here and the socket was reset, then this socket 
	// should be closed so that no more clients can connect to it.  However, 
	// we can't go to the BSD SKT_CLOSED state directly since the user still 
	// has to call closesocket() with this s SOCKET descriptor first.
	if(bSocketWasReset)
	{
		TCPClose(socket->SocketID);
		socket->bsdState = SKT_DISCONNECTED;
		return TRUE;
	}
	
	return FALSE;
}
Exemplo n.º 13
0
void HTTPServer(void)
{
  if (SocketStatus & SOCK_CONNECTED)             // check if somebody has connected to our TCP
  {
    if (SocketStatus & SOCK_DATA_AVAILABLE)      // check if remote TCP sent data
      TCPReleaseRxBuffer();                      // and throw it away

    if (SocketStatus & SOCK_TX_BUF_RELEASED)     // check if buffer is free for TX
    {
      if (!(HTTPStatus & HTTP_SEND_PAGE))        // init byte-counter and pointer to webside
      {                                          // if called the 1st time
        HTTPBytesToSend = strlen(WebSide) - 1;   // get HTML length, ignore trailing zero
        PWebSide = (unsigned char *)WebSide;     // pointer to HTML-code
      }

      if (HTTPBytesToSend > MAX_TCP_TX_DATA_SIZE)     // transmit a segment of MAX_SIZE
      {
        if (!(HTTPStatus & HTTP_SEND_PAGE))           // 1st time, include HTTP-header
        {
          memcpy(TCP_TX_BUF, GetResponse, sizeof(GetResponse) - 1);
          memcpy(TCP_TX_BUF + sizeof(GetResponse) - 1, PWebSide, MAX_TCP_TX_DATA_SIZE - sizeof(GetResponse) + 1);
          HTTPBytesToSend -= MAX_TCP_TX_DATA_SIZE - sizeof(GetResponse) + 1;
          PWebSide += MAX_TCP_TX_DATA_SIZE - sizeof(GetResponse) + 1;
        }
        else
        {
          memcpy(TCP_TX_BUF, PWebSide, MAX_TCP_TX_DATA_SIZE);
          HTTPBytesToSend -= MAX_TCP_TX_DATA_SIZE;
          PWebSide += MAX_TCP_TX_DATA_SIZE;
        }
          
        TCPTxDataCount = MAX_TCP_TX_DATA_SIZE;   // bytes to xfer
        InsertDynamicValues();                   // exchange some strings...
        TCPTransmitTxBuffer();                   // xfer buffer
      }
      else if (HTTPBytesToSend)                  // transmit leftover bytes
      {
        memcpy(TCP_TX_BUF, PWebSide, HTTPBytesToSend);
        TCPTxDataCount = HTTPBytesToSend;        // bytes to xfer
        InsertDynamicValues();                   // exchange some strings...
        TCPTransmitTxBuffer();                   // send last segment
        TCPClose();                              // and close connection
        HTTPBytesToSend = 0;                     // all data sent
      }

      HTTPStatus |= HTTP_SEND_PAGE;              // ok, 1st loop executed
    }
  }
  else
    HTTPStatus &= ~HTTP_SEND_PAGE;               // reset help-flag if not connected
}
Exemplo n.º 14
0
/***	void TCPSocket::close(void)
**
**	Synopsis:   
**      Closes the socket and clears the TCPSocket instance;
**      Returns the instance to a just constructed state releasing
**      all resources.
**
**	Parameters:
**      None
**
**	Return Values:
**      None
**
**	Errors:
**      None
**
**  Notes:
**
**      Returns the TCPSocket instance to
**      a state just as if the instance had just been
**      constructed. It also, Close the connection if
**      if it is still active.
**
*/
void TCPSocket::close(void)
{
    if(_classState != ipsNotInitialized)
    {
        // clean out the buffer
        TCPDiscard(&_socket);

        // release the resources back to stack
        TCPClose(&_socket, NULL);
    }

    // reset our member variables
    clear(false);
 }
Exemplo n.º 15
0
//processing http protocol , and excuting the followed fuction.
void WebServer(uint8 s)
{
	int ret;
	uint32 header_len=0, content_len=0, received_len=0;
	char sub[10];

	/* http service start */
	ret = TCPRecv(s, (int8*)rx_buf, MAX_URI_SIZE);

	if(ret > 0){					// If Received..
		*(((uint8*)rx_buf)+ret) = '\0';

		if(strstr(rx_buf, "Content-Length: ")){
			mid((char*)rx_buf, "Content-Length: ", "\r\n", sub);
			content_len=atoi(sub);
			header_len = (uint32)(strstr(rx_buf, "\r\n\r\n") - rx_buf + 4);

			received_len = ret;
			while(received_len!=(content_len+header_len))
			{
				ret = TCPRecv(s, (int8*)rx_buf+received_len, MAX_URI_SIZE);
				received_len+=ret;
			}

			*(((uint8*)rx_buf)+received_len) = '\0';
		}

		HTTPProcessor(s, (char*)rx_buf);	// request is processed
		memset(rx_buf,0x00,MAX_URI_SIZE);

		TCPDisconnect(s);

	} else if(ret == SOCKERR_NOT_TCP){		// Not TCP Socket, It's UDP Socket
		DBG("UDP Socket Close");
		UDPClose(s);

	} else if(ret == SOCKERR_CLOSED){			// Socket Closed
		LOGA("HTTP Server Started - ch(%d)",(uint16)s);
		TCPServerOpen(s, DEFAULT_HTTP_PORT);
	}

	if(GetTCPSocketStatus(s) == SOCKERR_CLOSE_WAIT){// Close waiting
		TCPClose(s);
	}
}
Exemplo n.º 16
0
/*****************************************************************************
*
*  exoHAL_SocketClose
*
*  \param  socket - socket handle
*
*  \return None
*
*  \brief  Closes a socket
*
*****************************************************************************/
void
exoHAL_SocketClose(long socket)
{
  // Send everything immediately
  if (GenericTCPState == EX_DISCONNECT)
  {
    if (TCPIsConnected((TCP_SOCKET)exSocket) && socket_crush == 1)
    {
      TCPClose((TCP_SOCKET)exSocket);
      socket_crush = 0;
      exSocket = INVALID_SOCKET;
      socket = exSocket;
    }
    send_count = 0;
    GenericTCPState = EX_DONE;
  }
  return;
}
Exemplo n.º 17
0
/***	void TcpClient::close(void)
**
**	Synopsis:   
**      Closes the socket and clears the TcpClient instance;
**      Returns the instance to a just constructed state releasing
**      all resources.
**
**	Parameters:
**      None
**
**	Return Values:
**      None
**
**	Errors:
**      None
**
**  Notes:
**
**      Returns the TcpClient instance to 
**      a state just as if the instance had just been
**      constructed. It also, Close the connection if
**      if it is still active.
**
*/
void TcpClient::close(void)
{
    if(_hTCP < INVALID_SOCKET)
    {
        // clean out the buffer
        TCPDiscard(_hTCP);

        // release the resources back to the MAL
        TCPClose(_hTCP);
    }

    // we are just closed
    _hTCP = INVALID_SOCKET;
    _classState = DNETcK::NotConnected;

    // say the enpoints are gone too
    _fEndPointsSetUp = false;
 }
Exemplo n.º 18
0
/*
 * FUNCTION: Closes an connection file object
 * ARGUMENTS:
 *     Request = Pointer to TDI request structure for this request
 * RETURNS:
 *     Status of operation
 */
NTSTATUS FileCloseConnection(
  PTDI_REQUEST Request)
{
  PCONNECTION_ENDPOINT Connection;

  TI_DbgPrint(MID_TRACE, ("Called.\n"));

  Connection = Request->Handle.ConnectionContext;

  if (!Connection) return STATUS_INVALID_PARAMETER;

  TCPClose( Connection );

  Request->Handle.ConnectionContext = NULL;

  TI_DbgPrint(MAX_TRACE, ("Leaving.\n"));

  return STATUS_SUCCESS;
}
Exemplo n.º 19
0
/**
 * @brief	This function listenes the eventing message from IGD(Internet Gateway Device).
 */
void eventing_listener(
  SOCKET sockfd 	/**< a socket number. */
  )
{
	uint16 len;
        const uint8 HTTP_OK[] = "HTTP/1.1 200 OK\r\n\r\n";

	switch (getSn_SR(sockfd))
	{
		case SOCK_ESTABLISHED:					/* if connection is established */
			Delay_ms(500);
			if((len = getSn_RX_RSR(sockfd)) > 0){
				TCPRecv(sockfd, (void *)recv_buffer, len);
				TCPSend(sockfd, (void *)HTTP_OK, strlen((void *)HTTP_OK));
				parseEventing(recv_buffer);
#ifdef UPNP_DEBUG
				printf("\r\nReceiveData\r\n%s\r\n", recv_buffer);
#endif
			}

		break;

		case SOCK_CLOSE_WAIT:					/* If the client request to close */
			if ((len = getSn_RX_RSR(sockfd)) > 0) 		/* check Rx data */
			{
				TCPRecv(sockfd, (void *)recv_buffer, len);	/* read the received data */
			}
			TCPClose(sockfd);
		break;

		case SOCK_CLOSED:					/* if a socket is closed */
			if(TCPServerOpen(sockfd,PORT_UPNP_EVENTING) == FAIL)	/* reinitialize the socket */
			{
				printf("\r\n%d : Fail to create socket.",sockfd);
			}
		break;

		default:
		break;
	}
}
Exemplo n.º 20
0
/****************************************************************************
  Function:
   TCP_SOCKET ChipKITClientConnect(unsigned int dwOpenVal, BYTE vRemoteHostType, unsigned short wPort, unsigned int cSecTimout)

  Description:
    This routine opens a socket and for clients only, attempts to connect to the server.
	DNS lookups are done if a URL is specifed for dwOpenVal and vRemoteHostType == TCP_OPEN_RAM_HOST
	
  Precondition:
    None

  Parameters:
    dwOpenVal		- Same as in TCPOpen
	vRemoteHostType	- Same as in TCPOpen
	wPort			- Same as in TCPOpen
	cSecTimout		- If this is a client connecting to a host, this is the number of seconds to wait for a 
						successful connection to occur

  Returns:
   	The valid socket if the open was successful, or INVALID_SOCKET if no sockets were avaiable or 
	the connection was not made (in the case of a client)

  Remarks:
	This routine will attempt to wait until the connection is made for client, but will return immediately for servers as servers
	listen for connections. For the client case, if cSecTimout is exceeded, the connection is close and the socket released back to
	the stack for reuse.
   ***************************************************************************/
TCP_SOCKET ChipKITClientConnect(unsigned int dwOpenVal, BYTE vRemoteHostType, unsigned short wPort, unsigned int cSecTimout)
{
	TCP_SOCKET hTCP = UNKNOWN_SOCKET;
	DWORD t = 0;

	hTCP = TCPOpen((DWORD) dwOpenVal, vRemoteHostType, (WORD) wPort, TCP_PURPOSE_DEFAULT);
	ChipKITPeriodicTasks();

	// if it just fails, don't even attempt a retry
	if(hTCP == INVALID_SOCKET)
	{
		return(hTCP);
	}

	// if this is a client, we have to wait until we connect
	// No need to do this for servers as they connect when some one comes in on the listen
	if(vRemoteHostType != TCP_OPEN_SERVER) 
	{
		t = TickGet(); // so we don't loop forever
		while(!TCPIsConnected(hTCP))
		{
		 	ChipKITPeriodicTasks();
	
			// if after 10 seconds we do not connect, just fail and clean up
			if( (TickGet() - t) >= (cSecTimout * TICK_SECOND))
			{
				TCPClose(hTCP);
				TCPDiscard(hTCP);
				hTCP = INVALID_SOCKET;
				
				// make sure we run tasks again to get for the close to take effect
				// so don't return here, break out of the while to clean up
				break;  
			}
		}
				
		ChipKITPeriodicTasks();
	}

	return(hTCP);
}
Exemplo n.º 21
0
/***	void TcpServer::close(void)
**
**	Synopsis:   
**      Stops Listening and closes all unaccepted sockets/connections
**      and clears everything back to it's originally constructed state.
**
**	Parameters:
**      None
**
**	Return Values:
**      None
**
**	Errors:
**      None
**
**  Notes:
**
**      Returns the TcpServer instance to 
**      a state just as if the instance had just been
**      constructed. It also, Close all connections
**      and releases all resources (sockets).
**
*/
void TcpServer::close(void)
{
    stopListening();

    for(int i = 0; i<_cMaxPendingAllowed; i++)
    {
        if(_rghTCP[i] < INVALID_SOCKET)
        {
            // clean out the buffer
            TCPDiscard(_rghTCP[i]);

            // release the resources back to the MAL
            TCPClose(_rghTCP[i]);

            // invalidate the socket
            _rghTCP[i] = INVALID_SOCKET;
        }
    }

    clear();
}
Exemplo n.º 22
0
/***	void TcpServer::stopListening(void)
**
**	Synopsis:   
**      This stops listening on the server port, but does not shutdown TcpServer
**
**	Parameters:
**     None
**
**	Return Values:
**      None
**
**	Errors:
**      None
**
**  Notes:
**      To resume listening, just call ResumeListening
**      This is a soft stop listening in that only the server stops listening on the port
**      however the instance is still valid and you can continue to accept pending client.
**      and you can resume the listening.
**
*/
void TcpServer::stopListening(void)
{
    // DO NOT blow away pending clients.
    // that will be done on a close()
    // update the pending count so we have them all.
    availableClients();

    if(_cPending < _cPendingMax && _rghTCP[_cPending] < INVALID_SOCKET)
    {
        // clean out the buffer
        TCPDiscard(_rghTCP[_cPending]);

        // release the resources back to the MAL
        TCPClose(_rghTCP[_cPending]);

        // only invalidate if this is the listening socket
        _rghTCP[_cPending] = INVALID_SOCKET;
    }

    // no longer listening
    _fListening = false;
}
Exemplo n.º 23
0
/****************************************************************************
  Function:
    void ChipKITClientStop(TCP_SOCKET hTCP)

  Description:
    This routine closes the socket, discards the input buffer, and returns the socket to the TCPIP stack.

  Precondition:
    hTCP must be open and valid.

  Parameters:
    hTCP - The socket to close

  Returns:
    none

  Remarks:
	This is to match functionality of the Arduino Client class stop method
  ***************************************************************************/
void ChipKITClientStop(TCP_SOCKET hTCP)
{

	// the MAL can hang if you attempt to close an invalid socket
	if(hTCP == INVALID_SOCKET || hTCP == UNKNOWN_SOCKET)
	{
		return;
	}

	// close the handle
	TCPClose(hTCP);

	// empty the receive buffer because we are killing it.
	TCPDiscard(hTCP);

	// loop until it is acknowledged to be closed
	do
	{
		ChipKITPeriodicTasks();
	} while(TCPIsConnected(hTCP));	

}
Exemplo n.º 24
0
/*****************************************************************************
*
* Cloud_GetCmd
*
*  \param  pbuf - string buffer containing data to be sent
*          bufsize - number of bytes to send
*
*  \return 1 success; 0 failure
*
*  \brief  Writes data to Exosite cloud
*
*****************************************************************************/
int
Cloud_GetCmd()
{
  int length;
  char DataLen[10];
//  int http_status = 0;
  char *cmp_ss = "Content-Length:";
  char *cmp = cmp_ss;
  DWORD serverip = 0;
  const unsigned char server[6] = SERVERIP ;
  serverip = (server[3] << 24 & 0xff000000) | (server[2] << 16 & 0xff0000)
          | (server[1] << 8 & 0xff00) | (server[0] & 0xff);
  long w, r;
  char rev[300];
  unsigned char len;
  char *p;
  unsigned char crlf = 0;
  int  time_out = 0;
  int tx_buff_size = 250;

  int  tmp_len =0 ;

  if(status_code == STATUS_INIT||status_code == STATUS_END){

      if (sock == INVALID_SOCKET)
      {
        sock = TCPOpen(serverip, TCP_OPEN_IP_ADDRESS, HTTP_PORT, TCP_PURPOSE_TCP_CLIENT);

      // TCP_OPEN_RAM_HOST for using dns name as server name
     //  TCPOpen(serverip, TCP_OPEN_IP_ADDRESS, server_port, TCP_PURPOSE_GENERIC_TCP_CLIENT);

       if (sock  == INVALID_SOCKET) {
             status_code = STATUS_INIT;
       //      LEDS_OFF();
        //     LEDS_ON();
            return 0;
         }
       status_code = STATUS_READY;

      }
      else  status_code == STATUS_READY;
  }
  else if(status_code == STATUS_READY)
  {
       if(sent_header) DelayMs(20);
        w = TCPIsPutReady(sock);

       if(w<=250ul) {
              return 0; }

       if(sent_header){

             memset(header, 0, sizeof(header));
             length = PostHeaderGenerate("/sendcmd.php", command, 0, 0);
             remain_count =0 ;
             sent_header = FALSE;
             sent_count = 0;
       }
    //    LED2_ON(); LED1_OFF();

       int send_len = strlen(&header[remain_count]);

   //   LED2_ON(); LED1_OFF();
      //if(send_len > 254)  {LED2_ON(); LED1_OFF()};
      /*  The max size of sliding window for TCP packet is 254? after testing.
       *  Don't know the reason, but if we set the number of sending data to 250,
       * the program works fine.
       *
       */
      tmp_len = send_len>250? 250:send_len;
  //    int tmp_len = IHMS_SocketSend(sock, &header[sent_count], send_len );

      tmp_len = TCPPutArray(sock, (BYTE *) &header[remain_count], tmp_len);

      TCPFlush((TCP_SOCKET)sock);

      LED2_ON(); LED1_OFF();

     if(tmp_len<send_len)
     {
         remain_count += tmp_len;
         return 0;
     }
     memset(header, 0, sizeof(header));
     sent_count = 0;
     remain_count = 0;
     status_code = STATUS_RCV;

  }
   else if(status_code == STATUS_RCV)
  {
     DelayMs(20);
     r = TCPIsGetReady((TCP_SOCKET) sock);

     if(r<200u){ LED2_ON();  return 0;}
     // now read all data in RX buffer

    int count = 0;
    do
    {
        r = TCPGetArray((TCP_SOCKET)sock, (BYTE *)&rev[count], 300);
        count  = count + r;
        rev[count]=0;

        r = TCPIsGetReady((TCP_SOCKET) sock);

     }while(r>0u);

    rev[count] = 0 ;

    TCPClose((TCP_SOCKET)sock);
    status_code = STATUS_END;
    sock = INVALID_SOCKET;
    status_code = STATUS_END;

    sent_header = TRUE;
    //now it's time to read time

    command = GetServerCmd(rev, "cmd=");
    cmd_no = GetServerCmd(rev, "no=");

    return 1;

  }

  return 0;
}
Exemplo n.º 25
0
/*****************************************************************************
  Function:
	int closesocket( SOCKET s )
	
  Summary:
	The closesocket function closes an existing socket.

  Description:
	The closesocket function closes an existing socket.  
	This function releases the socket descriptor s.  
	Any data buffered at the socket is discarded.  If the 
	socket s is no longer needed, closesocket() must be 
	called in order to release all resources associated with s.

  Precondition:
	None.

  Parameters:
	s - Socket descriptor returned from a previous call to socket

  Returns:
	If closesocket is successful, a value of 0 is returned. 
	A return value of SOCKET_ERROR (-1) indicates an error.

  Remarks:
	None.
  ***************************************************************************/
int closesocket( SOCKET s )
{	
	BYTE i;
	struct BSDSocket *socket;

	if( s >= BSD_SOCKET_COUNT )
		return SOCKET_ERROR;

	socket = &BSDSocketArray[s];

	if(socket->bsdState == SKT_CLOSED)
		return 0;	// Nothing to do, so return success

	if(socket->SocketType == SOCK_STREAM)
	{
		if(socket->bsdState == SKT_BSD_LISTEN)
		{
			// This is a listerner handle, so when we close it we also should 
			// close all TCP sockets that were opened for backlog processing 
			// but didn't actually get connected
			for(i = 0; i < sizeof(BSDSocketArray)/sizeof(BSDSocketArray[0]); i++)
			{
				if(BSDSocketArray[i].bsdState != SKT_LISTEN)
					continue;
				if(BSDSocketArray[i].localPort == socket->localPort)
				{
					TCPClose(BSDSocketArray[i].SocketID);
					BSDSocketArray[i].bsdState = SKT_CLOSED;
				}
			}
		}
		else if(socket->bsdState >= SKT_LISTEN)
		{
			// For server sockets, if the parent listening socket is still open, 
			// then return this socket to the queue for future backlog processing.
			if(socket->isServer)
			{
				for(i = 0; i < sizeof(BSDSocketArray)/sizeof(BSDSocketArray[0]); i++)
				{
					if(BSDSocketArray[i].bsdState != SKT_BSD_LISTEN)
						continue;
					if(BSDSocketArray[i].localPort == socket->localPort)
					{
						TCPDisconnect(socket->SocketID);
						
						// Listener socket is still open, so just return to the 
						// listening state so that the user must call accept() again to 
						// reuse this BSD socket
						socket->bsdState = SKT_LISTEN;
						return 0;
					}
				}
				// If we get down here, then the parent listener socket has 
				// apparently already been closed, so this socket can not be 
				// reused.  Close it complete.
				TCPClose(socket->SocketID);
			}
			else if(socket->bsdState != SKT_DISCONNECTED)	// this is a client socket that isn't already disconnected
			{
				TCPClose(socket->SocketID);
			}
		}
	}
	else //udp sockets
	{
		if(socket->bsdState == SKT_BOUND)
			UDPClose(socket->SocketID);
	}

	socket->bsdState = SKT_CLOSED;
	return 0; //success
}
Exemplo n.º 26
0
//****************************************************************************
//	Only internal use:
//	TCPGenericClose callback function
//****************************************************************************
int cTCPGenericClose()
{
	TCPClose(xSocket);
	return 0;
}
Exemplo n.º 27
0
Arquivo: ftp.c Projeto: KISSMonX/W7200
void ftp_client_PI (uint8 sock)
{
        int   ret;
        int   idx;
	char  msg[STR_SIZE];
	uint16 status;
	static uint16 any_port = 50000;
	
        memset(cmd_buf, 0, sizeof(cmd_buf));
        ret = TCPRecv(sock, cmd_buf, TX_RX_MAX_BUF_SIZE);

        if(ret > 0)							// Received
	{
        	for( idx=0; idx < ret; idx++ )
                {
			if( idx == 0 )
				printf("\r\n");
                 
			printf("%c",cmd_buf[idx]);
                }
          
                switch( status = Parse_FTPServer_Statuscode(cmd_buf) )
		{
			case R_220:					// Service ready for new user.
                                printf("\r\nInput your User ID > ");
				GetInputString(msg);
                                Send_USER_ID(sock,msg);
				break;
			
				
			case R_331:					// User name okay, need password.
				printf("\r\nInput your Password > ");
				GetInputString(msg);
				Send_PW(sock,msg);
				break;
			

			case R_230:					// User logged in, proceed
			  	printf("\r\nUser logged in, proceed");
			  	TCPClose(FTP_CLIENT_DTP_SOCK);
				Send_Port(sock, IP, DTP_Port);
				break;


			case R_200:					// 'Generic' command ok
				printf("\r\nInput FTP CMD > ");
				GetInputString(msg);
				Send_cmd(sock, msg);
				break;
			
				
			case R_150:					// File Status ok: opening data conn
				bRunDTP = 1;
				break;
			  	
				
			case R_250:
				TCPClose(FTP_CLIENT_DTP_SOCK);
				Send_Port(sock, IP, DTP_Port);
				break;
				
			
			case R_226:					/* Closing data connection.  File transfer/abort successful */
				TCPClose(FTP_CLIENT_DTP_SOCK);
				Send_Port(sock, IP, DTP_Port);
				break;
				

			case R_425:
				TCPClose(FTP_CLIENT_DTP_SOCK);
				Send_Port(sock, IP, DTP_Port);
				break;
				
			default:
			  	printf("\r\nDefault Status = %d",(uint16)status);
								
				JumpAddress = *(volatile unsigned long*) (ApplicationAddress + 4);	// reset app
				Jump_To_Application = (pFunction) JumpAddress;
				Jump_To_Application();
				while(1);
		}
	}
	else if(ret == ERROR_CLOSED || ret == ERROR_CLOSE_WAIT )
	{
		  printf("\r\n%d : FTP Client Start.\r\n",(u16)sock);
		  if( TCPClientOpen( sock, any_port++, FTP_SERVER_IP, FTP_Server_CMD_Port ) == 0 )
			  printf("< Fail : Socket Connect >\r\n");
	}
}
Exemplo n.º 28
0
Arquivo: ftp.c Projeto: KISSMonX/W7200
void ftp_client_DTP(uint8 sock)
{
	int   len;
        int   idx;
	
	
	switch( GetTCPSocketStatus(sock) )
	{
		case STATUS_ESTABLISHED:
			if(bRunDTP)
			{
				bRunDTP = 0;
#ifdef Debug				
				printf("< FTP_DTP Connect OK>\r\n");
#endif
			}
                        
                        len = TCPRecv(sock, data_buf, TX_RX_MAX_BUF_SIZE);
                        
                        if( len > 0 )
                        {
				for( idx = 0; idx < len; idx++ )
				{
					if( idx == 0 )
						printf("\r\n");
					
					printf("%c",data_buf[idx]);
				}
                        }
			
			if( bRunPutFile )
			{
				bRunPutFile = 0;
				TCPSend(sock, (void *)PUTFILE, strlen(PUTFILE));
				TCPClose(sock);
			}
			break;
			
		case STATUS_CLOSE_WAIT:
                        
			len = TCPRecv(sock, data_buf, TX_RX_MAX_BUF_SIZE);
                        
                        if( len > 0 )
                        {
				for( idx = 0; idx < len; idx++ )
				{
					if( idx == 0 )
						printf("\r\n");
					
					printf("%c",data_buf[idx]);
				}
                        }
			
			if( bRunPutFile )
			{
				bRunPutFile = 0;
				TCPSend(sock, (void *)PUTFILE, strlen(PUTFILE));
			}

			TCPClose(sock);
			break;
			
		case STATUS_CLOSED:
			
			TCPClose(sock);
			if( TCPServerOpen( sock, DTP_Port++ ) == 0 )
			{
				printf("\r\nDTP Socket Open Error");
				break;
			}
                        
                        if( DTP_Port > 70000 )
                                DTP_Port = FTP_Client_TCPS_Port;
                        
			bRunDTP = 1;
			break;
	}	
}
Exemplo n.º 29
0
void ReceiveEthernetCmds()
{
	
	WORD wMaxGet, wBytesRead;
	BYTE b;
	static enum _TCPServerState
	{
		SM_HOME = 0,
		SM_LISTENING,
        SM_CLOSING,
	} TCPServerState = SM_HOME;
	
	switch(TCPServerState)
	{
		case SM_HOME:
			// Allocate a socket for this server to listen and accept connections on
			MySocket = TCPOpen(0, TCP_OPEN_SERVER, SERVER_PORT, TCP_PURPOSE_GENERIC_TCP_SERVER);
			if(MySocket == INVALID_SOCKET)
				return;

			TCPServerState = SM_LISTENING;
			break;

		case SM_LISTENING:
			// See if anyone is connected to us
			if(!TCPIsConnected(MySocket))
				return;
				
			// Figure out how many bytes have been received and how many we can transmit.
			wMaxGet = TCPIsGetReady(MySocket);	// Get TCP RX FIFO byte count
			
			
			// Read the data into the buffer
			wBytesRead = 0;
			while (wBytesRead < wMaxGet)
			{
				if(!TCPGet(MySocket, &b)) 
					break;	// Byte NOT read... (No connection or no data to read)
				
				if(b == 10 || b == 13)
				{
					// Ignore newline characters
				}
				else
				{
					EthernetBuffer[EB_Write] = b;
					if( (EB_Write+1) % ETHERNET_BUFFER_SIZE != EB_Read)	// check if buffer full
						EB_Write++;
					EB_Write %= ETHERNET_BUFFER_SIZE;
				}
				wBytesRead++;
			}	
	
			break;
			
		case SM_CLOSING:
			// Close the socket connection.
            TCPClose(MySocket);

			TCPServerState = SM_HOME;
			break;
	}
	
	ProcessBufferData();
	
}	
Exemplo n.º 30
0
/*****************************************************************************
*
* Cloud_Activate
*
*  \param  None
*
*  \return 1  - activation success
*          0  - activation failure
*
*  \brief  Called after Init has been run in the past, but maybe comms were
*          down and we have to keep trying
*
*****************************************************************************/
int
Cloud_Activate(void)
{
  int length;
  char DataLen[5];
  int newcik = 0;
//  int http_status = 0;
  char *cmp_ss = "Content-Length:";
  char *cmp = cmp_ss;
  DWORD serverip = 0;
  const unsigned char server[6] = SERVERIP;
  serverip = (server[3] << 24 & 0xff000000) | (server[2] << 16 & 0xff0000)
          | (server[1] << 8 & 0xff00) | (server[0] & 0xff);
  long w, r;
  char rev[300];
  unsigned char strLen, len;
  unsigned char cik_len_valid = 0;
  char *p;
  unsigned char crlf = 0;
  unsigned char ciklen = 0;
  int   time_out = 0;
  // Flag cloud_initialized is set by Cloud_Init()
  /*
  if (!cloud_initialized) {
    status_code = STATUS_INIT;
    return newcik;
  }
    */

  // clean the content of http header array

  if(status_code == STATUS_INIT||status_code == STATUS_END){

      //to launch a new HTTP POST operation, clean the content of header at first

      if (sock == INVALID_SOCKET)
      {
        sock = TCPOpen(serverip, TCP_OPEN_IP_ADDRESS, HTTP_PORT, TCP_PURPOSE_TCP_CLIENT);

      // TCP_OPEN_RAM_HOST for using dns name as server name
     //  TCPOpen(serverip, TCP_OPEN_IP_ADDRESS, server_port, TCP_PURPOSE_GENERIC_TCP_CLIENT);

       if (sock  == INVALID_SOCKET) {
             status_code = STATUS_INIT;
       //      LEDS_OFF();
        //     LEDS_ON();
            return 0;
         }
       status_code = STATUS_READY;

      }
      status_code == STATUS_READY;
  }
  else if(status_code == STATUS_READY)
  {
      // Get activation Serial Number
        DelayMs(20);
        w = TCPIsPutReady(sock);

        if(w<2000ul) {
           //   StackTask();
          //  TCPFlush((TCP_SOCKET)sock);
              return 0; }

  //      LED1_ON(); LED2_OFF();

       // if(w>2000ul) { LED2_ON(); LED1_OFF();}

     //   DelayMs(100);
        length = strlen(provision_info);

        IHMS_itoa(DataLen, length, 10); //make a string for length

        sendLine(sock, POSTDATA_LINE, "/activate.php");
        sendLine(sock, HOST_LINE, NULL);
        sendLine(sock, CONTENT_LINE, NULL);
     //   IHMS_SocketSend(sock, "Connection: close\r\n", sizeof("Connection: close\r\n")-1);

        sendLine(sock, LENGTH_LINE, DataLen);

        IHMS_SocketSend(sock, provision_info, length);

        status_code = STATUS_RCV;
  }
  else if(status_code == STATUS_RCV)
  {
     DelayMs(20);
     r = TCPIsGetReady((TCP_SOCKET) sock);

     if(r<234u){ LED2_ON();  return 0;}
     // now read all data in RX buffer

    int count = 0;
    do
    {
        r = TCPGetArray((TCP_SOCKET)sock, (BYTE *)&rev[count], 300);
        count  = count + r;
        rev[count]=0;

        r = TCPIsGetReady((TCP_SOCKET) sock);

     }while(r>0u);

     rev[count] = 0 ;
      strLen = strlen(rev);
      len = strLen;
      p = rev;
      // Find 4 consecutive \r or \n - should be: \r\n\r\n
      while (0 < len && 4 > crlf)
      {
        if ('\r' == *p || '\n' == *p)
        {
          ++crlf;
        }
        else
        {
          crlf = 0;
          if (*cmp == *p)
          {
            // check the cik length from http response
            cmp++;
            if (cmp > cmp_ss + strlen(cmp_ss) - 1)
              cik_len_valid = 1;
          }
          else
            cmp = cmp_ss;
        }
        ++p;
        --len;
      }

     if(len>0)
     {
         LED1_ON();
         LED2_OFF();
     }



      // The body is the cik
        // TODO, be more robust - match Content-Length header value to CIK_LENGTH
      strncpy(CIK, p, CIK_LENGTH);

      CIK[40] = 0;
      newcik = 1;

    //IHMS_SocketClose(sock);

    TCPClose((TCP_SOCKET)sock);
    status_code = STATUS_END;
    sock = INVALID_SOCKET;

    return newcik;
  }

 // status_code = STATUS_INIT;
  return newcik;

}