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; }
/** 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; }
// 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; }
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; }
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; }
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; }
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(); }
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); } } }
/* * @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; }
// 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); }
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); }
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; }
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); } } }
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; }
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); } }
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; }
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 ; }
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)); }
/// 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 ); }
// 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; }
///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?? }
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; }
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; } } }
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 ; }
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); }
/* * @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; }
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; }
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; } } } }
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); }
/*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; }