コード例 #1
0
ファイル: protocol.c プロジェクト: authorNari/panda
static	void
GL_RecvLBS(
	NETFILE	*fp,
	LargeByteString	*lbs)
{
	size_t	size;
ENTER_FUNC;
	size = GL_RecvLength(fp);
	LBS_ReserveSize(lbs,size,FALSE);
	if		(  size  >  0  ) {
		Recv(fp,LBS_Body(lbs),size);
		if		(  !CheckNetFile(fp)  ) {
			GL_Error();
		}
	} else {
		dbgmsg("Recv LBS 0 size.");
	}
LEAVE_FUNC;
}
コード例 #2
0
ファイル: ocland_mem.c プロジェクト: sanguinariojoe/ocland
/** Thread that receives image from client.
 * @param data struct dataTransfer casted variable.
 * @return NULL
 */
void *asyncDataRecvImage_thread(void *data)
{
    struct dataSend* _data = (struct dataSend*)data;
    // Provide a server for the data transfer
    int fd = accept(_data->fd, (struct sockaddr*)NULL, NULL);
    if(fd < 0){
        // we can't work, disconnect the client
        printf("ERROR: Can't listen on binded port.\n"); fflush(stdout);
        shutdown(_data->fd, 2);
        return CL_SUCCESS;
    }
    // We may wait manually for the events generated by ocland,
    // and then we can wait for the OpenCL generated ones.
    if(_data->num_events_in_wait_list){
        oclandWaitForEvents(_data->num_events_in_wait_list, _data->event_wait_list);
    }
    // Receive the data
    Recv(&fd, _data->ptr, _data->cb, MSG_WAITALL);
    // Writre it into the buffer
    clEnqueueWriteImage(_data->command_queue,_data->mem,CL_FALSE,
                        _data->buffer_origin,_data->region,
                        _data->buffer_row_pitch,_data->buffer_slice_pitch,
                        _data->ptr,0,NULL,&(_data->event->event));
    // Wait until the data is copied before start cleaning up
    clWaitForEvents(1,&(_data->event->event));
    // Clean up
    free(_data->ptr); _data->ptr = NULL;
    if(_data->event){
        _data->event->status = CL_COMPLETE;
    }
    if(_data->want_event != CL_TRUE){
        free(_data->event); _data->event = NULL;
    }
    if(_data->event_wait_list) free(_data->event_wait_list); _data->event_wait_list=NULL;
    // shutdown(fd, 2);
    // shutdown(_data->fd, 2); // Destroy the server to free the port
    close(fd);
    close(_data->fd);
    free(_data); _data=NULL;
    pthread_exit(NULL);
    return NULL;
}
コード例 #3
0
ファイル: USBCore.cpp プロジェクト: Bouni/Arduino
//	Does not timeout or cross fifo boundaries
int USB_RecvControl(void* d, int len)
{
	auto length = len;
	while(length)
	{
		// Dont receive more than the USB Control EP has to offer
		// Use fixed 64 because control EP always have 64 bytes even on 16u2.
		auto recvLength = length;
		if(recvLength > 64){
			recvLength = 64;
		}

		// Write data to fit to the end (not the beginning) of the array
		WaitOUT();
		Recv((u8*)d + len - length, recvLength);
		ClearOUT();
		length -= recvLength;
	}
	return len;
}
コード例 #4
0
ファイル: common.c プロジェクト: dulton/solotools
int  recv_until_flag(int sockfd, const char *flg, int len_flg, char **ut_buf, u32 *pack_len)
{
    const char *pFlg = NULL;
	char buf[1024 * 5] = {0};
	char *ptr_new = NULL;
    char *pRecv = NULL;
	int nRecv = 0;
    int size_new = 0; 

    pFlg = flg;
    pRecv = buf;
	while ((nRecv = Recv(sockfd, pRecv, 1, 0)) == 1)
	{
        if (*pRecv == *pFlg) 
        {
            ++pFlg;
            // find flag
            if (pFlg - flg == len_flg)
            {
                size_new = *pack_len + (pRecv - buf) + 1;
                ptr_new = (char*)realloc(*ut_buf, size_new);
                if (ptr_new == NULL)
                {
                    logdbg_fmt("recv_until_flag: realloc failed 1! size:%d\n", size_new);
                    return -1;
                }

                *ut_buf = ptr_new;
                memcpy(*ut_buf + *pack_len, buf, (pRecv - buf) + 1);
                *pack_len = size_new;
                break;
            }
        }
        else
        {
            pFlg = flg;
        }
        ++pRecv;
	}
	return (nRecv <= 0) ? -1:1;
}
コード例 #5
0
bool CPythonNetworkStream::__RecvChangeName()
{
    TPacketGCChangeName ChangeNamePacket;
    if (!Recv(sizeof(TPacketGCChangeName), &ChangeNamePacket))
        return false;

    for (int i = 0; i < PLAYER_PER_ACCOUNT4; ++i)
    {
        if (ChangeNamePacket.pid == m_akSimplePlayerInfo[i].dwID)
        {
            m_akSimplePlayerInfo[i].bChangeName = FALSE;
            strncpy(m_akSimplePlayerInfo[i].szName, ChangeNamePacket.name, CHARACTER_NAME_MAX_LEN);

            PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnChangeName", Py_BuildValue("(is)", i, ChangeNamePacket.name));
            return true;
        }
    }

    PyCallClassMemberFunc(m_apoPhaseWnd[PHASE_WINDOW_SELECT], "OnCreateFailure", Py_BuildValue("(i)", 100));
    return true;
}
コード例 #6
0
ファイル: AccountConnector.cpp プロジェクト: adi97ida/Client
bool CAccountConnector::__AuthState_RecvChinaMatrixCard()
{
	TPacketGCChinaMatrixCard kMatrixCardPacket;
	if (!Recv(sizeof(TPacketGCChinaMatrixCard), &kMatrixCardPacket))
		return false;

	if (m_poHandler)
	{
		PyObject * pyValue = Py_BuildValue("(iiiiiiii)",	ROW(kMatrixCardPacket.dwRows, 0),
															ROW(kMatrixCardPacket.dwRows, 1),
															ROW(kMatrixCardPacket.dwRows, 2),
															ROW(kMatrixCardPacket.dwRows, 3),
															COL(kMatrixCardPacket.dwCols, 0),
															COL(kMatrixCardPacket.dwCols, 1),
															COL(kMatrixCardPacket.dwCols, 2),
															COL(kMatrixCardPacket.dwCols, 3));
		PyCallClassMemberFunc(m_poHandler, "OnMatrixCard", pyValue);
	}

	return true;
}
コード例 #7
0
void Cube_SocketTCP_Connect::run()
{
	int ssize;
	Cube_SocketTCP_Connect_I _in;
	while(TRUE)
	{
		if (ssize=recv(m_Client.s,(char *)_in.Buffer,CUBE_SOCKETTCP_I_BUFFERSIZE,0)==SOCKET_ERROR)
		{
		break;
		}
		if (ssize!=0)
		{
			Recv(_in);
		}
		else
		{
			break;
		}
	}
	Offline();
}
コード例 #8
0
ファイル: tcprecv02.c プロジェクト: elftech/vmware-code
int
main(int argc, char **argv)
{
	int		listenfd, connfd, n;
	char	buff[100];
	fd_set	rset, xset;

	if (argc == 2)
		listenfd = Tcp_listen(NULL, argv[1], NULL);
	else if (argc == 3)
		listenfd = Tcp_listen(argv[1], argv[2], NULL);
	else
		err_quit("usage: tcprecv02 [ <host> ] <port#>");

	connfd = Accept(listenfd, NULL, NULL);

	FD_ZERO(&rset);
	FD_ZERO(&xset);
	for ( ; ; ) {
		FD_SET(connfd, &rset);
		FD_SET(connfd, &xset);

		Select(connfd + 1, &rset, NULL, &xset, NULL);

		if (FD_ISSET(connfd, &xset)) {
			n = Recv(connfd, buff, sizeof(buff)-1, MSG_OOB);
			buff[n] = 0;		/* null terminate */
			printf("read %d OOB byte: %s\n", n, buff);
		}

		if (FD_ISSET(connfd, &rset)) {
			if ( (n = Read(connfd, buff, sizeof(buff)-1)) == 0) {
				printf("received EOF\n");
				exit(0);
			}
			buff[n] = 0;	/* null terminate */
			printf("read %d bytes: %s\n", n, buff);
		}
	}
}
コード例 #9
0
ファイル: data_am.c プロジェクト: chenneal/postsi
/*
 * @return: '0' to rollback, '1' to go head.
 */
int Data_Insert(int table_id, TupleId tuple_id, TupleId value, int nid)
{
	int index;
	int status;
	uint64_t h;
	DataRecord datard;
	THREAD* threadinfo;

	/* get the pointer to current thread information. */
	threadinfo=(THREAD*)pthread_getspecific(ThreadInfoKey);
	index=threadinfo->index;

	/*
	 * the node transaction process must to get the data from the storage process in the
	 * node itself or in the other nodes, both use the socket to communicate.
	 */

	int lindex;
	lindex = GetLocalIndex(index);
    if ((Send3(lindex, nid, cmd_insert, table_id, tuple_id)) == -1)
       printf("insert send error!\n");
    if ((Recv(lindex, nid, 2)) == -1)
       printf("insert recv error!\n");

    status = *(recv_buffer[lindex]);
    h = *(recv_buffer[lindex]+1);

    if (status == 0)
    	return 0;

	datard.type=DataInsert;
	datard.table_id=table_id;
	datard.tuple_id=tuple_id;
	datard.value=value;
	datard.index=h;
	datard.node_id = nid;
	DataRecordInsert(&datard);

	return 1;
}
コード例 #10
0
ファイル: PassiveSock.cpp プロジェクト: david-maw/StreamSSL
// Receives exactly Len bytes of data and returns the amount received - or SOCKET_ERROR if it times out
int CPassiveSock::ReceiveBytes(void * const lpBuf, const int Len)
{
    int
    bytes_received = 0,
    total_bytes_received = 0;

    RecvEndTime = CTime::GetCurrentTime() + CTimeSpan(0,0,0,TimeoutSeconds);

    while (total_bytes_received < Len)
    {
        bytes_received = Recv((char*)lpBuf+total_bytes_received, Len-total_bytes_received);
        if (bytes_received == SOCKET_ERROR)
            return SOCKET_ERROR;
        else if (bytes_received == 0)
            break; // socket is closed, no data left to receive
        else
        {
            total_bytes_received += bytes_received;
        }
    }; // loop
    return (total_bytes_received);
}
コード例 #11
0
ファイル: shift_util.C プロジェクト: DeanHowarth/QUDA-CPS
CPS_START_NAMESPACE
void GlobalDataShift::Shift(int mu, int n_disp){
  if (n_disp==0) return;
 
  SCUDir s_dir,r_dir;
  int a_disp;
  void *send_p,*recv_p,*temp_p;
  if (n_disp>0){
   a_disp = n_disp;
   s_dir = gjp_scu_dir[mu*2];
   r_dir = gjp_scu_dir[mu*2+1];
  } else {
   a_disp = -n_disp;
   s_dir = gjp_scu_dir[mu*2+1];
   r_dir = gjp_scu_dir[mu*2];
  }

  send_p = addr;
  recv_p = temp_buf;

  SCUDirArgIR Send(send_p,s_dir,SCU_SEND,data_len);
  SCUDirArgIR Recv(recv_p,r_dir,SCU_REC,data_len);

  sys_cacheflush(0);
  for(int i = 0;i<a_disp-1;i++){
    Send.StartTrans();Recv.StartTrans();
    Send.TransComplete();Recv.TransComplete();
    temp_p = send_p;
    send_p = recv_p;
    recv_p = temp_p;
    Send.Addr(send_p);
    Recv.Addr(recv_p);
  }
  Send.StartTrans();Recv.StartTrans();
  Send.TransComplete();Recv.TransComplete();

  if (recv_p != addr)
    memcpy(addr,recv_p,data_len);
}
コード例 #12
0
ファイル: protocol.c プロジェクト: authorNari/panda
static	void
GL_RecvString(
	NETFILE	*fp,
	size_t  maxsize,
	char	*str)
{
	size_t		lsize;
ENTER_FUNC;
	lsize = GL_RecvLength(fp);
	if		(	maxsize >= lsize 	){
		Recv(fp,str,lsize);
		if		(  !CheckNetFile(fp)  ) {
			GL_Error();
		}
		str[lsize] = 0;
	} else {
		ShowErrorDialog(
		_("GL_RecvString invalid size %ld > %ld(max size)"),
		(unsigned long)lsize,(unsigned long)maxsize);
	}
LEAVE_FUNC;
}
コード例 #13
0
void XShellProcess::run()
{
	//Receive buffer size must be large than 3
	assert(sizeof(m_RecvBuffer)>3);

	DWORD dwRere=0;

	while(TRUE)
	{
		if(m_hReadPipe1!=INVALID_HANDLE_VALUE&&m_bConsoleActivate)
		{
			PeekNamedPipe(m_hReadPipe1,m_RecvBuffer, sizeof(m_RecvBuffer),&m_lBytesRead,0,0);
			if(m_lBytesRead)
			{
			memset(m_RecvBuffer, 0, sizeof(m_RecvBuffer));  
			if(ReadFile(m_hReadPipe1,m_RecvBuffer,sizeof(m_RecvBuffer)-2,&m_lBytesRead,0))
			{
			if (m_RecvBuffer[sizeof(m_RecvBuffer)-3]&0x80)
			{
				if(!ReadFile(m_hReadPipe1,m_RecvBuffer+sizeof(m_RecvBuffer)-2,1,&dwRere,0))
					break;
			}
			XShellProcess_I In;
			In.Buffer=m_RecvBuffer;
			In.size=m_lBytesRead+dwRere;
			Recv(In);
			}
			}
			else
			{
			Sleep(300);
			}
		}
		else
		{
			Sleep(300);
		}
	}
}
コード例 #14
0
bool CPythonNetworkStream::RecvSafeBoxSetPacket()
{
	TPacketGCItemSet2 kItemSet;
	if (!Recv(sizeof(kItemSet), &kItemSet))
		return false;

	TItemData kItemData;
	kItemData.vnum	= kItemSet.vnum;
	kItemData.count = kItemSet.count;
	kItemData.flags = kItemSet.flags;
	kItemData.anti_flags = kItemSet.anti_flags;
	for (int isocket=0; isocket<ITEM_SOCKET_SLOT_MAX_NUM; ++isocket)
		kItemData.alSockets[isocket] = kItemSet.alSockets[isocket];
	for (int iattr=0; iattr<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++iattr)
		kItemData.aAttr[iattr] = kItemSet.aAttr[iattr];

	CPythonSafeBox::Instance().SetItemData(kItemSet.Cell.cell, kItemData);

	__RefreshSafeboxWindow();

	return true;
}
コード例 #15
0
ファイル: mgrIhpvc.c プロジェクト: lvluo3/mgr
void * hpvc_client_thread(void * p)
{
		int avfd;
		char buf[512];
		int  len;
		while(1)
		{
				if( -1 != hpvc_client_init())
				{
						while(1)
						{
								len = Recv(hpvcfd , buf , 512 , 0);
								if(len == 0)
								{
										fprintf(stderr , "mgrIhpvc recv == 0\n");
										close(hpvcfd);
										hpvcfd = -1;
										break;
										//			exit(-1);
								}

								hpvcmgr_defifo(&hpvc_usr);
								avfd = *((int *)hpvc_usr.p);

								fprintf(stderr , "recv hpvcmgr reply , pktlen : %d , pkttype : %d , reserve %d , dspnum : %d , avfd : %d\n" , 
												htons(*((short*)buf)) , htons(*((short*)(buf + 2))) , htons(*(short*)(buf + 4)) ,  htonl(*(int*)(buf + 6)) ,  avfd);

								send(avfd , buf , len , 0);
						}
				}
				else
				{
						sleep(5);
						continue;
				}
				hpvcmgr_destroy_memdata(&hpvc_usr.mem_list);
				sleep(1);
		}
}
コード例 #16
0
bool CPythonNetworkStream::RecvPingPacket()
{
	Tracef("recv ping packet. (securitymode %u)\n", IsSecurityMode());

	TPacketGCPing kPacketPing;

	if (!Recv(sizeof(TPacketGCPing), &kPacketPing))
		return false;

	m_dwLastGamePingTime = ELTimer_GetMSec();

	TPacketCGPong kPacketPong;
	kPacketPong.bHeader = HEADER_CG_PONG;

	if (!Send(sizeof(TPacketCGPong), &kPacketPong))
		return false;

	if (IsSecurityMode())
		return SendSequence();
	else
		return true;
}
コード例 #17
0
ファイル: Master.cpp プロジェクト: belldandyxtq/burstbuffer
void Master::_send_file_meta(int clientfd, std::string& ip)const
{
	ssize_t file_no; 
	fprintf(stderr, "requery for File meta data, ip=%s\n", ip.c_str());
	Recv(clientfd, file_no); 
	const file_info *file=NULL; 
	try
	{
		file=&(_buffered_files.at(file_no));
		Send(clientfd, SUCCESS);
	}
	catch(std::out_of_range &e)
	{
		const char OUT_OF_RANGE[]="out of range\n"; 
		Send(clientfd, OUT_OF_RANGE);
		return; 
	}
	Send(clientfd, file->size);
	Send(clientfd, file->block_size);
	close(clientfd);
	return ;
}
コード例 #18
0
ファイル: sproc.cpp プロジェクト: kolyden/mirror
void RemoteSlaveProcess::Open(const char *host, int port, const char *cmdline, const char *envptr, int to)
{
    SVRLOG("RemoteSlaveProcess(" << host << ":" << port << ")=" << cmdline);
    Kill();

    timeout = to;
    Socket::Init();
    String localhost;
    if(host == 0 || *host == 0)
    {
        localhost = Socket::GetHostName();
        host = localhost;
    }
    if(port == 0)
        port = DEFAULT_PORT;
    terminated = false;
    current_part = 0;
    output[0] = output[1] = output[2] = Null;
    if(!ClientSocket(socket, host, port, true, NULL, REQUEST_TIMEOUT))
        throw Exc(NFormat(t_("Opening host '%s' / port %d failed, error = %s"), host, port, Socket::GetErrorText()));
    int len = (int)strlen(cmdline);
    if(envptr && *envptr) {
        const char *e = envptr;
        while(*e)
            e = e + strlen(e) + 1;
        socket.Write(":");
        socket.Write(ASCII85Encode(String(envptr, e + 1)));
        socket.Write("\n");
    }
    socket.Write("=");
    socket.Write(cmdline, len + 1); // send terminating 0 as well
    Recv(0, timeout);
    if(output[0][0] == '-')
        throw Exc(NFormat(t_("Error running process: %s\nCommand: %s"), output[0].Begin() + 1, cmdline));

    if(output[0] != "+")
        throw Exc(NFormat(t_("Communication error; process = %s"), cmdline));
}
コード例 #19
0
ファイル: msg_object.cpp プロジェクト: MangoCats/winglib
/// Routes the message to a remote or local destination
CMsg CMsgObjectInfo::Send( CMsg &x_rMsg )
{
    // Sanity check
    if ( !x_rMsg.IsValid() )
        return CMsg();

    // Can't be routed without an id
    if ( guid::CmpGuid( &IID_ZEROS, &x_rMsg.Mi().Dst()->GetId() ) )
        return CMsg();

    // Set our id in the return address
    x_rMsg.Mi().Src()->SetInstance( &m_guidId );

    // Is it for us?
    if ( guid::CmpGuid( &IID_ZEROS, &x_rMsg.Mi().Dst()->GetInstance() )
         || guid::CmpGuid( &m_guidId, &x_rMsg.Mi().Dst()->GetInstance() ) )
    {   
        // Short circuit the reply queue if needed
        if ( x_rMsg.Mi().WantReply() )
        {
            // Create reply signal
            x_rMsg.EnableReplyEvent( oexTRUE );

            // Set direct reply flag
            x_rMsg.SetDirectReply( oexTRUE );

        } // end if

        // Receive the message
        Recv( x_rMsg );
        
        return x_rMsg;

    } // end if

    // Send through the network
    return oexNet.Send( x_rMsg );
}
コード例 #20
0
// Item
// Recieve
bool CPythonNetworkStream::RecvItemSetPacket()
{
	TPacketGCItemSet packet_item_set;

	if (!Recv(sizeof(TPacketGCItemSet), &packet_item_set))
		return false;

	TItemData kItemData;
	kItemData.vnum	= packet_item_set.vnum;
	kItemData.count	= packet_item_set.count;
	kItemData.flags = 0;
	for (int i=0; i<ITEM_SOCKET_SLOT_MAX_NUM; ++i)
		kItemData.alSockets[i]=packet_item_set.alSockets[i];
	for (int j=0; j<ITEM_ATTRIBUTE_SLOT_MAX_NUM; ++j)
		kItemData.aAttr[j]=packet_item_set.aAttr[j];

	IAbstractPlayer& rkPlayer=IAbstractPlayer::GetSingleton();
	
	rkPlayer.SetItemData(packet_item_set.Cell, kItemData);
	
	__RefreshInventoryWindow();
	return true;
}
コード例 #21
0
ファイル: MyConnection.cpp プロジェクト: ferot/Monitoring
///Metoda wołana przy odbieraniu danych
void MyConnection::OnRecv( std::vector< uint8_t > & buffer )
{
	global_stream_lock.lock();
	std::cout << "[" << __FUNCTION__ << "] " << buffer.size() << " bytes" << std::endl;
	for( size_t x = 0; x < buffer.size(); ++x )
	{
		std::cout <<(char)buffer[ x ] << " ";
		if( ( x + 1 ) % 16 == 0 )
		{
			std::cout << std::endl;
		}
	}
	std::cout << std::endl;
	global_stream_lock.unlock();
	Recv();
	p->SigW(NET,&buffer);
	//p->work(nullptr);
	// Start the next receive


	// Echo the data back
	//Send( buffer ); TODO: send ACK to server??
}
コード例 #22
0
ファイル: JackNetInterface.cpp プロジェクト: HI-CARL/jack2
    int JackNetSlaveInterface::DataRecv()
    {
        int rx_bytes = 0;
        uint recvd_midi_pckt = 0;
        packet_header_t* rx_head = reinterpret_cast<packet_header_t*>(fRxBuffer);

        while (!fRxHeader.fIsLastPckt) {
            // how much data is queued on the rx buffer ?
            rx_bytes = Recv(fParams.fMtu, MSG_PEEK);

            // error here, just skip the cycle (return -1)
            if (rx_bytes == SOCKET_ERROR) {
                return rx_bytes;
            }

            if (rx_bytes && (rx_head->fDataStream == 's') && (rx_head->fID == fParams.fID)) {
                // read data
                switch (rx_head->fDataType) {

                    case 'm':   // midi
                        rx_bytes = MidiRecv(rx_head, fNetMidiCaptureBuffer, recvd_midi_pckt);
                        break;

                    case 'a':   // audio
                        rx_bytes = AudioRecv(rx_head, fNetAudioCaptureBuffer);
                        break;

                    case 's':   // sync
                        jack_info("NetSlave : missing last data packet");
                        return FinishRecv(fNetAudioCaptureBuffer);
                }
            }
        }

        fRxHeader.fCycle = rx_head->fCycle;
        return rx_bytes;
    }
コード例 #23
0
void receive_file(int sockfd)
{
	char str[30];
	const int on = 1;
	int flags = 0;
	int sequence_number = 0;
	size_t n = 1;

	// Send the initial window size to the server
	send_packet.window_size = cdata.sliding_window_size;
	Send(sockfd, &send_packet, sizeof(send_packet), 0);

	// Receive the packets in a loop and send ACK
	while(n > 0)
	{
		n = Recv(sockfd, &recv_packet, sizeof(recv_packet), 0);
		
		add_packet_to_buffer(&recv_packet);

		read_packet_from_buffer();

		// Send ACK to the server
		send_packet.seq = sequence_number;
		send_packet.last_flag = recv_packet.last_flag;
		send_packet.window_size = current_window_size;
		send_packet.ack = recv_packet.seq + 1;

		Send(sockfd, &send_packet, sizeof(send_packet), flags);

		if(recv_packet.last_flag == 1)
		{
			printf("\n[INFO]Last flag set\n");
			break;		
		} 
	}

}
コード例 #24
0
ファイル: TcpClient.cpp プロジェクト: cchd0001/gld_work
void TcpClient::RealConnect(const std::string& ip, const std::string& port)
{
    if( status_ != TcpConnStatus::Invaid ) {
        return ;
    }
    Resolver resolver(io_service_);
    Resolver::query query(ip, port);
    Resolver::iterator endpoint_it = resolver.resolve(query);

    auto handle_connected = [&](const ConnectionPtr& conn, const ErrorCode& e) {
        if (!e) {
            if( status_ == TcpConnStatus::Connecting ) {
                status_ = TcpConnStatus::Connected ;
            }
            Recv();
        } else {
            status_ = TcpConnStatus::Invaid ;
        }
        conn->OnConnected(e);
    };
    boost::asio::async_connect(GetSocket().socket(), endpoint_it,
        std::bind(handle_connected, shared_from_this(), std::placeholders::_1));
    status_ = TcpConnStatus::Connecting ;
}
コード例 #25
0
ファイル: blobreq.c プロジェクト: authorNari/panda
extern	Bool
RequestExportBLOB(
	NETFILE	*fp,
	MonObjectType	obj,
	char			*fname)
{
	Bool	rc;
	char	buff[SIZE_BUFF];
	FILE	*fpf;
	size_t	size
		,	left;

ENTER_FUNC;
	rc = FALSE;
	RequestBLOB(fp,BLOB_EXPORT);		ON_IO_ERROR(fp,badio);
	SendObject(fp,obj);					ON_IO_ERROR(fp,badio);
	if		(  RecvPacketClass(fp)  ==  BLOB_OK  ) {
		if		(  ( fpf = Fopen(fname,"w") )  !=  NULL  ) {
			fchmod(fileno(fpf),0600);
			left = RecvLength(fp);
			while	(  left  >  0  ) {
				size = (  left  >  SIZE_BUFF  ) ? SIZE_BUFF : left;
				Recv(fp,buff,size);			ON_IO_ERROR(fp,badio);
				fwrite(buff,size,1,fpf);
				left -= size;
			}
			fclose(fpf);
			rc = TRUE;
		} else {
			Warning("could not open for write: %s", fname);
		}
	}
  badio:
LEAVE_FUNC;
	return	(rc);
}
コード例 #26
0
ファイル: data_am.c プロジェクト: chenneal/postsi
/*
 * @return:'1' for success, '-1' for rollback.
 */
int TrulyDataInsert(int table_id, int index, TupleId tuple_id, TupleId value, int nid)
{
	int index2;
	int status;
	TransactionData* tdata;
	TransactionId tid;
	DataLock lockrd;
	THREAD* threadinfo;

	tdata=(TransactionData*)pthread_getspecific(TransactionDataKey);
	tid=tdata->tid;

	threadinfo=(THREAD*)pthread_getspecific(ThreadInfoKey);
	index2=threadinfo->index;

	int lindex;
	lindex = GetLocalIndex(index2);

    if((Send6(lindex, nid, cmd_trulyinsert, table_id, tuple_id, value, index, tid)) == -1)
    	printf("truly insert send error!\n");
    if((Recv(lindex, nid, 1)) == -1)
    	printf("truly insert recv error!\n");

	/* record the lock. */
	lockrd.table_id=table_id;
	lockrd.tuple_id=tuple_id;
	lockrd.index = index;
	lockrd.node_id = nid;
	lockrd.lockmode=LOCK_EXCLUSIVE;
	DataLockInsert(&lockrd);

    status = *(recv_buffer[lindex]);
    if (status == 4)
    	return -1;
	return 1;
}
コード例 #27
0
int32_t CInsideSocket::OnRead(int32_t nErrorCode)
{
	uint8_t arrBuf[enmMaxMessageSize];

	int32_t nCloseCode = 0;
	int32_t nRecvBytes = 0;
	int32_t nRet = Recv(arrBuf, sizeof(arrBuf), nRecvBytes);
	if(nRet != S_OK)
	{
		nCloseCode = nRet;
	}

	m_stRecvBuffer.Write(arrBuf, nRecvBytes);
	//提取消息包
	MakeMessage();

	if(nCloseCode != 0)
	{
		CloseSocket(nCloseCode);
		return E_SOCKETERROR;
	}

	return S_OK;
}
コード例 #28
0
ファイル: AtmelProc.c プロジェクト: Veetiglik/train-project
void InitAtmelControlProc()
{
	//bind to this process' message queue
	Bind(ATMELMQNUM);

	//wait for synchronization message from keyboardProc to begin
	char dummyBlock[1];
	int syncSrc = KBMQNUM;
	Recv(&syncSrc, ATMELMQNUM, dummyBlock, 1);

	//local variables for message passing
	int src = -1;
	char recvBuffer[RECV_BUFFER_SIZE];
	char sendHallSensorBuffer[SEND_HS_BUFFER_SIZE];

	//initialize cursor position for hall sensor display output
	//UpdateCursorPos(&(GetRunning()->cursorPosState), 23, 2);
	int currentCursorRow = HS_CURSOR_UPPER_LIMIT;
	UpdateCursorPos(&(GetRunning()->cursorPosState), currentCursorRow, 2);


	bool initialized = false; //set to true once track hardware has been initialized

	while(true) //the main loop of the Atmel Communication Process
	{
		src = -1; //-1 means "accept messages from any source"

		//clean the receive buffer
		int j;
		for(j = 0; j < 6; j++)
		{
			recvBuffer[j] = 0;
		}

		//blocking recieve waiting for messages
		Recv(&src, ATMELMQNUM, recvBuffer, -1);//because the src is unknown, size is determined by the sender

		switch(src) //two sources are supported: HS Process and Loco process.
		{
			case HSMQNUM:
			{
				switch(recvBuffer[0])
				{
					case 0:	//reset sensors and set switches
					{
						//init HS queues of atmel 1
						SendPacket *out_packet = InitHallSensorQueueInit();
						RecvPacket *in_packet = (RecvPacket*)Allocate(sizeof(RecvPacket));
						SendAndReceivePacket(out_packet, in_packet, 1);

						//init HS queues of atmel 3
						SendPacket *out_packet2 = InitHallSensorQueueInit();
						RecvPacket *in_packet2 = (RecvPacket*)Allocate(sizeof(RecvPacket));
						SendAndReceivePacket(out_packet2, in_packet2, 3);

						if(GetRecvSuccess(in_packet) && GetRecvSuccess(in_packet2))
						{
							//reset all HS (atmel 1 only)
							SendPacket *out_packet3 = InitHallSensorAllReset();
							RecvPacket *in_packet3 = (RecvPacket*)Allocate(sizeof(RecvPacket));

							SendAndReceivePacket(out_packet3, in_packet3, 1);

							Deallocate((uint32_t)out_packet);
							Deallocate((uint32_t)in_packet);
							Deallocate((uint32_t)out_packet2);
							Deallocate((uint32_t)in_packet2);
							Deallocate((uint32_t)out_packet3);
							Deallocate((uint32_t)in_packet3);

							initialized = true;

							//send back to HS to acknowledge that HS queues were initialized
							Send(ATMELMQNUM, HSMQNUM, recvBuffer, sizeof(char));
						}
						else
						{
							char *failure = "FATAL ERROR initalizing HS queues\n\r\0";
							WriteString(failure);
						}
						break;
					}
					default://1 or 3
					{
						if(initialized) //do not act on other messages if we haven't initialized the queues yet
						{
							//query which hall sensor was triggered
							SendPacket *out_packet = InitHallSensorInput();
							RecvPacket *in_packet = (RecvPacket*)Allocate(sizeof(RecvPacket));

							SendAndReceivePacket(out_packet, in_packet, (int)recvBuffer[0]);

							//examine the rx'd packet to determine the hall sensor number
							int sensorNum = -1;
							bool successfulSPI = GetHallSensorNum(in_packet, &sensorNum);

							Deallocate((uint32_t)out_packet);
							Deallocate((uint32_t)in_packet);

							//send which hall sensor triggered to LocoProc
							if(successfulSPI)
							{
								//output the HS number to the console
								char testHSNum[4];
								testHSNum[0] = sensorNum/10 + 0x30;
								testHSNum[1] = sensorNum%10 + 0x30;
								testHSNum[2] = ' ';
								testHSNum[3] = '\0';

								UpdateCursorPos(&(GetRunning()->cursorPosState), currentCursorRow, 2);
								OutputCursorPositionSequence(&(GetRunning()->cursorPosState));
								WriteStringChar('+');
								WriteString(testHSNum);

								//make sure the stream of hall sensor printouts stays on the screen.
								currentCursorRow = (currentCursorRow == HS_CURSOR_LOWER_LIMIT)? HS_CURSOR_UPPER_LIMIT: currentCursorRow +1;

								//send reset acknowledgement to Atmel 1 for hall sensor triggering
								SendPacket *out_packet2 = InitHallSensorSingleReset(sensorNum);
								RecvPacket *in_packet2 = (RecvPacket*)Allocate(sizeof(RecvPacket));

								SendAndReceivePacket(out_packet2, in_packet2, 1);

								if(GetRecvSuccess(in_packet2))
								{
									Deallocate((uint32_t)out_packet2);
									Deallocate((uint32_t)in_packet2);
								}
								else
								{
									char *failure = "FATAL ERROR when acknowledging Hall Sensor event\n\r\0";
									WriteString(failure);
								}

								if(lastSensorTriggered != sensorNum) //Some hall sensors will double-trigger intermittently as a train passes, so ignore successive duplicates
								{
									sendHallSensorBuffer[0] = (char)sensorNum;
									//tell the LocoProc which hall sensor was just hit
									Send(ATMELMQNUM, LOCOMQNUM, sendHallSensorBuffer, SEND_HS_BUFFER_SIZE);
								}

								lastSensorTriggered = sensorNum;
							}
							else
							{
								char *failure = "FATAL ERROR when getting hall sensor number\n\r\0";
								WriteString(failure);
							}
						}
						break;
					}
				}
				break;
			}
			case LOCOMQNUM:
			{
				switch(recvBuffer[0])
				{
					case SPI_SEGMENT_SPEED_DIR://set segment speed and dir
					{
						SendPacket *out_packet = InitDirAndMagFor1Section(recvBuffer[1], recvBuffer[2], recvBuffer[3]);
						RecvPacket *in_packet = (RecvPacket*)Allocate(sizeof(RecvPacket));
						SendAndReceivePacket(out_packet, in_packet, 1);

						if(GetRecvSuccess(in_packet))
						{
							Deallocate((uint32_t)out_packet);
							Deallocate((uint32_t)in_packet);
						}
						else
						{
							char *failure = "FATAL ERROR when setting single segment speed\n\r\0";
							WriteString(failure);
						}

						break;
					}
					case SPI_SWITCH://set switch as thrown or straight
					{
						SendPacket *out_packet = InitSwitchControl(recvBuffer[1], recvBuffer[2]);
						RecvPacket *in_packet = (RecvPacket*)Allocate(sizeof(RecvPacket));
						SendAndReceivePacket(out_packet, in_packet, 2);

						if(GetRecvSuccess(in_packet))
						{
							Deallocate((uint32_t)out_packet);
							Deallocate((uint32_t)in_packet);
						}
						else
						{
							char *failure = "FATAL ERROR when using switch command\n\r\0";
							WriteString(failure);
						}
						break;
					}
					case SPI_ALL_SEGMENTS_SPEED_DIR: //and init the switches
					{
						SendPacket *out_packet = InitDirAndMagForAllSections(0, 1);//1 means CCW
						RecvPacket *in_packet = (RecvPacket*)Allocate(sizeof(RecvPacket));
						SendAndReceivePacket(out_packet, in_packet, 1);

						if(GetRecvSuccess(in_packet))
						{
							//straighten all switches
							int i;
							SendPacket *out_packet2 = InitSwitchControl(-1, 1);//1 means straight
							RecvPacket *in_packet2 = (RecvPacket*)Allocate(sizeof(RecvPacket));

							for(i = 1; i <= 9; i++)
							{
								out_packet2->arg1 = i;
								SendAndReceivePacket(out_packet2, in_packet2, 2);
							}

							Deallocate((uint32_t)out_packet);
							Deallocate((uint32_t)in_packet);
							Deallocate((uint32_t)out_packet2);
							Deallocate((uint32_t)in_packet2);

							//acknowledge to loco proc that track is initialized
							Send(ATMELMQNUM, LOCOMQNUM, recvBuffer, sizeof(char));
						}
						else
						{
							char *failure = "FATAL ERROR when setting all segments speed\n\r\0";
							WriteString(failure);
						}
						break;
					}
				}
				break;
			}
		}
	}
}
コード例 #29
0
ファイル: shift_util.C プロジェクト: DeanHowarth/QUDA-CPS
CPS_START_NAMESPACE
#ifndef USE_QMP
#define QMP
#endif

void GlobalDataShift::Shift(int direction, int n_disp){
  if (n_disp==0) return;
 
  SCUDir s_dir,r_dir;
  int a_disp;
  void *send_p,*recv_p,*temp_p;
#ifndef USE_QMP
  if (n_disp>0){
   a_disp = n_disp;
   s_dir = gjp_scu_dir[i*2];
   r_dir = gjp_scu_dir[i*2+1];
  } else {
   a_disp = -n_disp;
   s_dir = gjp_scu_dir[i*2+1];
   r_dir = gjp_scu_dir[i*2];
  }
#else
//  int direction = i;
  int sflag;
  if (n_disp > 0)
    sflag = +1;
  else
    sflag = -1;
#endif

  send_p = addr;
  recv_p = temp_buf;

#ifndef USE_QMP
  SCUDirArgIR Send(send_p,s_dir,SCU_SEND,data_len);
  SCUDirArgIR Recv(recv_p,r_dir,SCU_REC,data_len);
#else
  QMP_msgmem_t msgmem[2];
  QMP_msghandle_t msghandle[2];
  QMP_status_t status;
  QMP_msghandle_t multiple;
#endif

//  sys_cacheflush(0);
  for(int i = 0;i<a_disp-1;i++){

#ifndef USE_QMP
    Send.StartTrans();Recv.StartTrans();
    Send.TransComplete();Recv.TransComplete();
#else
    msgmem[0] = QMP_declare_msgmem((void *)send_p, data_len);
    msgmem[1] = QMP_declare_msgmem((void *)recv_p, data_len);
    msghandle[0] = QMP_declare_send_relative(msgmem[0], direction, sflag, 0);
    msghandle[1] = QMP_declare_receive_relative(msgmem[1], direction, -sflag, 0);
    multiple = QMP_declare_multiple(msghandle, 2);
    QMP_start(multiple);
    status = QMP_wait(multiple);
    if (status != QMP_SUCCESS)
      QMP_error("Error in GlobalDataShift::Shift:%s\n", QMP_error_string(status));
    QMP_free_msghandle(multiple);
    QMP_free_msgmem(msgmem[0]);
    QMP_free_msgmem(msgmem[1]);
#endif
  
    temp_p = send_p;
    send_p = recv_p;
    recv_p = temp_p;

#ifndef USE_QMP
    Send.Addr(send_p);
    Recv.Addr(recv_p);
#endif
  }
#ifndef USE_QMP
  Send.StartTrans();Recv.StartTrans();
  Send.TransComplete();Recv.TransComplete();
#else
  msgmem[0] = QMP_declare_msgmem((void *)send_p, data_len);
  msgmem[1] = QMP_declare_msgmem((void *)recv_p, data_len);
  msghandle[0] = QMP_declare_send_relative(msgmem[0], direction, sflag, 0);
  msghandle[1] = QMP_declare_receive_relative(msgmem[1], direction, -sflag, 0);
  multiple = QMP_declare_multiple(msghandle, 2);
  QMP_start(multiple);
  status = QMP_wait(multiple);
  if (status != QMP_SUCCESS)
    QMP_error("Error in GlobalDataShift::Shift:%s\n", QMP_error_string(status));
  QMP_free_msghandle(multiple);
  QMP_free_msgmem(msgmem[0]);
  QMP_free_msgmem(msgmem[1]);
#endif
  
  if (recv_p != addr)
    memcpy(addr,recv_p,data_len);
}
コード例 #30
0
/*thread for new client connection, arg is the client_fd*/
void *port_mapper_thread(void *arg){
    int sockfd = (int *)arg;

    //LoadLink *link;
    //link = threadArgs->loadLink;

    char logmsg[128]; 

    /* There are 5 types of Packets to be exchanged via port-mapper:
     * 1) Register service (from server to port mapper)         (000)
     * 2) Register acknowledge (from port mapper to server)     (001)
     * 3) Hello Packets (from server to port mapper)            (111)
     * 4) Request server location (from client to portmapper)   (010)
     * 5) Response server location (from portmapper to client)  (011)
     * */

    struct timeval *tmpcost, cost, timer; // use high quality timer to calculate the ping cost
    struct timezone tzp;

    /* keep receiving Data from server or client */
    //while(1){

    gettimeofday(&timer, &tzp);

    /*lock the send back in case it interrupt by other threads*/
    pthread_mutex_lock(&mutex);

    Packet *packet_recv; // MUST use pointer to fit different Packet
    packet_recv = (Packet *)calloc(1, sizeof(Packet));

    //printf("==port-mapper 1==");
    Recv(sockfd, packet_recv, sizeof(Packet), MSG_NOSIGNAL);

    //printf("==port-mapper 2==");
    /* Register service */
    if(strcmp(packet_recv->packet_type, "000") == 0){
        int dup_register = 0;
        //snprintf(logmsg, sizeof(logmsg), "serverthread(0x%x): packet_recv type: %s\n", pthread_self(), packet_recv->packet_type);
        //logging(LOGFILE, logmsg);
        dup_register = writePortMapperTable(packet_recv, PORT_MAPPER_TABLE_FILE);
        sendRegisterReply(sockfd, packet_recv, dup_register);
    }
    /* Hello packet */
    else if(strcmp(packet_recv->packet_type, "111") == 0){
        snprintf(logmsg, sizeof(logmsg), "serverthread(0x%x): packet_recv type: %s\n", pthread_self(), packet_recv->packet_type);
        logging(LOGFILE, logmsg);
        //sendHello(sockfd, router, threadParam->port);
    }
    /* Request server location */
    else if(strcmp(packet_recv->packet_type, "010") == 0 ){
        snprintf(logmsg, sizeof(logmsg), "serverthread(0x%x): packet_recv type: %s\n", pthread_self(), packet_recv->packet_type);
        logging(LOGFILE, logmsg);
        /*record the chosen response into loadlink*/
        sendRequestReply(sockfd, packet_recv);
    }
    //printf("==port-mapper 3==");

    pthread_mutex_unlock(&mutex);

    shutdown(sockfd, SHUT_RDWR);
    //snprintf(logmsg, sizeof(logmsg), "serverthread(0x%x): served request, exiting thread\n", pthread_self());
    //logging(LOGFILE, logmsg);

    //pthread_exit(0);
    free(packet_recv);
    pthread_exit((void *)link);
    //return (void *) threadArgs->loadLink;
}