static void *timer(UNUSED void *args) { CRecord *retry, *timed, *ping, *purge, *cr; int counter = 0; debugf("timer thread started\n"); for (;;) { if (nanosleep(&one_tick, NULL) != 0) break; ctable_lock(); if ((++counter % 500) == 0) { counter = 0; #ifdef VLOG logvf("Dump of connection table\n"); ctable_dump("LOGV> "); #endif /* VLOG */ } ctable_scan(&retry, &timed, &ping, &purge); while (purge != NULL) { cr = purge->link; ctable_remove(purge); crecord_destroy(purge); purge = cr; } while (timed != NULL) { cr = timed->link; crecord_setState(timed, ST_TIMEDOUT); timed = cr; } while (ping != NULL) { ControlPayload pl; cr = ping->link; cp_complete(&pl, ping->ep->subport, PING, ping->seqno, 1, 1); (void)send_payload(ping->ep, &pl, CP_SIZE); ping = cr; } while (retry != NULL) { cr = retry->link; switch(retry->state) { case ST_CONNECT_SENT: case ST_QUERY_SENT: case ST_RESPONSE_SENT: case ST_DISCONNECT_SENT: case ST_FRAGMENT_SENT: case ST_SEQNO_SENT: (void)send_payload(retry->ep, retry->pl, retry->size); break; } retry = cr; } ctable_unlock(); } return NULL; }
static void send_effect_names(void) { send_16(EFFECT_JSON_LEN); send_payload('['); for (uint8_t i = 0; i < effects_len; i++) { send_payload('"'); send_pgm_string(&effects[i].name); send_payload('"'); if (i < effects_len - 1) { send_payload(','); }; } send_payload(']'); }
static void send_zcl_header(uint8_t cmd) { send_payload(ZCL_CHANNEL); send_64(mac); send_payload(zcl.packet.endpoint); send_16(zcl.packet.profile); send_16(zcl.packet.cluster); // Send out the frame control byte //FIXME: see if needs to be non-zero send_payload(0); send_payload(zcl.packet.transaction_id); send_payload(cmd); }
int rpc_response(UNUSED RpcService rps, RpcEndpoint *ep, void *rb, unsigned len) { DataPayload *dp; int ans = 0; CRecord *cr; unsigned char *cp = (unsigned char *)rb; unsigned char fnum, nfrags; int size, blen; unsigned long fstates[2] = {ST_FACK_RECEIVED, ST_TIMEDOUT}; ctable_lock(); cr = ctable_look_ep(ep); if (cr != NULL && cr->state == ST_QACK_SENT) { nfrags = (len - 1) / FR_SIZE + 1; for (fnum = 1; fnum < nfrags; fnum++) { size = sizeof(PayloadHeader) + sizeof(DataHeader) + FR_SIZE; dp = (DataPayload *)malloc(size); cp_complete((ControlPayload *)dp, ep->subport, FRAGMENT, cr->seqno, fnum, nfrags); dp->dhdr.tlen = htons(len); dp->dhdr.flen = htons(FR_SIZE); memcpy(dp->data, &(cp[FR_SIZE*(fnum-1)]), FR_SIZE); cr->lastFrag = fnum; crecord_setPayload(cr, dp, size, ATTEMPTS, TICKS); (void)send_payload(ep, dp, size); crecord_setState(cr, ST_FRAGMENT_SENT); if (crecord_waitForState(cr, fstates, 2) == ST_TIMEDOUT) { ctable_unlock(); return 0; } } blen = len - FR_SIZE * (nfrags - 1); size = sizeof(PayloadHeader) + sizeof(DataHeader) + blen; dp = (DataPayload *)malloc(size); cp_complete((ControlPayload *)dp, ep->subport, RESPONSE, cr->seqno, fnum, nfrags); dp->dhdr.tlen = htons(len); dp->dhdr.flen = htons(blen); memcpy(dp->data, &(cp[FR_SIZE*(fnum-1)]), blen); crecord_setPayload(cr, dp, size, ATTEMPTS, TICKS); (void)send_payload(cr->ep, dp, size); crecord_setState(cr, ST_RESPONSE_SENT); ans = 1; } ctable_unlock(); return ans; }
void send_ima( tNode* pNode, BOOL fSendNow ) { IAnnexET00IAmAlive ima[sizeof_IAnnexET00IAmAlive_ND]; BYTE cookie[4]; ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS] = 0; AEPOr_T( ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_PFLAGS], AEPT_TransportMessage ); /* ima.Header.S = 0; ima.Header.A = 0; ima.Header.RES = 0; */ ima[IAnnexET00IAmAlive_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_IAmAlive; IMASet_P( ima ); hton16( (UINT16)get_ima_interval( pNode ), &ima[IAnnexET00IAmAlive_VALIDITY] ); IMASet_CookieLen( ima, sizeof( UINT32 ) ); hton32( timerGetTimeInMilliseconds(), &cookie[0] ); send_payload( pNode, ima, sizeof_IAmAliveHeader( &ima ), &cookie[0], 4, NULL, 0, FALSE, FALSE, fSendNow ); }
void send_ack( tNode* pNode, UINT32 seqn, BOOL fSendNow ) { IAnnexET00Ack ack[sizeof_IAnnexET00Ack_ND+sizeof_IAnnexEAckData]; ack[IAnnexET00Ack_Header+IAnnexET00Header_PFLAGS] = 0; /* ack.Header.T = 0; ack.Header.A = 0; ack.Header.S = 0; ack.Header.RES = 0; */ ack[IAnnexET00Ack_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_Ack; hton16( 1, &ack[IAnnexET00Ack_ACK_COUNT] ); hton24( seqn, &ack[IAnnexET00Ack_ACK+IAnnexEAckData_SEQNUM] ); ack[IAnnexET00Ack_ACK+IAnnexEAckData_RESERVED] = 0; send_payload( pNode, ack, sizeof_AckHeader( &ack ), &ack[IAnnexET00Ack_ACK], sizeof_IAnnexEAckData, NULL, 0, FALSE, FALSE, fSendNow ); }
void send_nack5( tNode* pNode,UINT32 seqn, int oid_length, BYTE* poid, BOOL fSendNow ) { /* send NACK REASON_5:"ObjectID-payload not supported!" */ IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader]; IAnnexENAckReason reason[sizeof_IAnnexENAckReason_ND]; msaPrintFormat( pNode->pAnnexE->msaType, "Send NAck5(ObjectID-payload not supported, SEQN=%i) to Host(%08x:%i)", seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort ); header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0; /* header.Header.T = 0; header.Header.A = 0; header.Header.S = 0; header.Header.RES = 0; */ header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck; hton16( 1, &header[IAnnexET00NAckHeader_NACK_COUNT] ); hton24( seqn, &reason[IAnnexENAckReason_SEQNUM] ); reason[IAnnexENAckReason_DATA_LENGTH] = (BYTE)(oid_length & 0xff); hton16( 5, &reason[IAnnexENAckReason_REASON] ); send_payload( pNode, header, sizeof_IAnnexET00NAckHeader, reason, sizeof_IAnnexENAckReason_ND, poid, oid_length, FALSE, FALSE, fSendNow ); }
void set_motor_current(float current) { int32_t index = 0; uint8_t payload[5]; payload[index++] = COMM_SET_CURRENT ; buffer_append_int32(payload, (int32_t)(current * 1000), &index); send_payload(payload, 5); }
void set_brake_current(float brakeCurrent) { int32_t index = 0; uint8_t payload[5]; payload[index++] = COMM_SET_CURRENT_BRAKE; buffer_append_int32(payload, (int32_t)(brakeCurrent * 1000), &index); send_payload(payload, 5); }
/* Function for sending the Payload */ int send_remote_notification(const char *deviceTokenHex, Payload *payload) { char messageBuff[MAXPAYLOAD_SIZE]; char tmpBuff[MAXPAYLOAD_SIZE]; char badgenumBuff[3]; strcpy(messageBuff, "{\"aps\":{"); if(payload->message != NULL) { strcat(messageBuff, "\"alert\":"); if(payload->actionKeyCaption != NULL) { sprintf(tmpBuff, "{\"body\":\"%s\",\"action-loc-key\":\"%s\"},", payload->message, payload->actionKeyCaption); strcat(messageBuff, tmpBuff); } else { sprintf(tmpBuff, "{\"%s\"},", payload->message); strcat(messageBuff, tmpBuff); } } if(payload->badgeNumber > 99 || payload->badgeNumber < 0) payload->badgeNumber = 1; sprintf(badgenumBuff, "%d", payload->badgeNumber); strcat(messageBuff, "\"badge\":"); strcat(messageBuff, badgenumBuff); strcat(messageBuff, ",\"sound\":\""); strcat(messageBuff, payload->soundName == NULL ? "default" : payload->soundName); strcat(messageBuff, "\"}"); int i = 0; while(payload->dictKey[i] != NULL && i < 5) { sprintf(tmpBuff, "\"%s\":\"%s\"", payload->dictKey[i], payload->dictValue[i]); strcat(messageBuff, tmpBuff); if(i < 4 && payload->dictKey[i + 1] != NULL) { strcat(messageBuff, ","); } i++; } strcat(messageBuff, "}"); printf("Sending %s\n", messageBuff); return send_payload(deviceTokenHex, messageBuff, strlen(messageBuff)); }
bool vesc_get_values(mc_values& values) { uint8_t command[1] = { COMM_GET_VALUES }; uint8_t payload[256]; send_payload(command, 1); delay(20); //needed, otherwise data is not read int lenPayload = process_received_msg(payload); if (lenPayload > 0) { bool read = process_read_package(payload, values, lenPayload); //returns true if sucessfull return read; } else { return false; } }
void i_am_alive_request_received( tNode* pNode, IAnnexET00IAmAlive* pPayload ) { msaPrintFormat( pNode->pAnnexE->msaType, "IAmAlive request from Host(%08x:%i)!", pNode->RemoteHost.nIP, pNode->RemoteHost.nPort ); IMAClr_P( pPayload ); send_payload( pNode, pPayload, sizeof_IAmAliveHeader( pPayload ), &pPayload[IAnnexET00IAmAlive_COOKIE], sizeof_IAmAliveCookie( pPayload ), NULL, 0, FALSE, FALSE, TRUE ); }
/* disconnect from target */ void rpc_disconnect(RpcConnection rpc) { CRecord *cr; ControlPayload *cp; RpcEndpoint *ep; //unsigned long states[1] = {ST_TIMEDOUT}; ctable_lock(); if ((cr = ctable_look_id((unsigned long)rpc)) == NULL) { ctable_unlock(); return; } ep = cr->ep; cp = (ControlPayload *)malloc(CP_SIZE); cp_complete(cp, ep->subport, DISCONNECT, cr->seqno, 1, 1); crecord_setPayload(cr, cp, CP_SIZE, ATTEMPTS, TICKS); (void) send_payload(ep, cp, CP_SIZE); crecord_setState(cr, ST_DISCONNECT_SENT); //(void) crecord_waitForState(cr, states, 1); ctable_unlock(); }
SAT_returnState tx_ecss(tc_tm_pkt *pkt) { int32_t ret = 0; uint16_t size = 0; SAT_returnState res; if(pkt == NULL){ comms_rf_stats_frame_transmitted(&comms_stats, 0, SATR_ERROR); return SATR_ERROR; } res = pack_pkt(send_buf, pkt, &size); if(res != SATR_OK){ comms_rf_stats_frame_transmitted(&comms_stats, 0, res); return ret; } ret = send_payload(send_buf, (size_t)size, 0,COMMS_DEFAULT_TIMEOUT_MS); if(ret < 1){ return SATR_ERROR; } free_pkt (pkt); return SATR_OK; }
/* {{{ proto string send(string token,string message) Send the apple_push data format */ PHP_METHOD(apple_push, send) { zend_class_entry * _this_ce; zval * _this_zval = NULL; const char * x = NULL; int x_len = 0; const char * y = NULL; int y_len = 0; if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "ss", &x, &x_len,&y,&y_len) == FAILURE) { return; } char tokenbytes[32]; string_to_bytes(x, tokenbytes); if(send_payload(ssl, tokenbytes, (char*)y,strlen( (char*)y))>=1) { RETURN_TRUE; } else { RETVAL_FALSE; } }
/** **************************************************************************************** * @brief Transmit a boot image to an SPI slave device **************************************************************************************** */ void spi_send_image (void) { uint8_t mode; uint8_t crc; uint8_t header_ack; uint8_t payload_ack; spi_booter_pad.pin = SPI_CS_PIN; spi_booter_pad.port = SPI_GPIO_PORT; crc = calc_crc(SPI_LENGTH); mode = 0x00; spi_init(&spi_booter_pad, SPI_MODE_8BIT, SPI_ROLE_MASTER, SPI_CLK_IDLE_POL_LOW, SPI_PHA_MODE_0, SPI_MINT_DISABLE, SPI_XTAL_DIV_4); do{ header_ack = send_header(SPI_LENGTH,crc,mode); if (header_ack) { payload_ack = send_payload(SPI_8BIT,SPI_LENGTH); break; } } while((header_ack&payload_ack)!=1); spi_release(); }
RpcConnection rpc_connect(char *host, unsigned short port, char *svcName, unsigned long seqno) { ConnectPayload *buf; RpcEndpoint *nep; int len = sizeof(PayloadHeader) + 1; /* room for '\0' */ CRecord *cr; unsigned long subport; unsigned long states[2] = {ST_IDLE, ST_TIMEDOUT}; unsigned long id = 0; ctable_lock(); subport = ctable_newSubport(); nep = rpc_socket(host, port, subport); if (nep != NULL) { id = gen_conn_id(); len += strlen(svcName); /* room for svcName */ buf = (ConnectPayload *)malloc(len); cp_complete((ControlPayload *)buf, nep->subport, CONNECT, seqno, 1, 1); strcpy(buf->sname, svcName); cr = crecord_create(nep, seqno); crecord_setCID(cr, id); crecord_setPayload(cr, buf, len, ATTEMPTS, TICKS); #ifdef LOG dumpsockNpacket(&(nep->addr), (DataPayload *)buf, "rpc_connect"); #endif /* LOG */ (void) send_payload(nep, buf, len); crecord_setState(cr, ST_CONNECT_SENT); ctable_insert(cr); if (crecord_waitForState(cr, states, 2) == ST_TIMEDOUT) { ctable_remove(cr); crecord_destroy(cr); id = 0; } ctable_unlock(); } return (RpcConnection)id; }
void send_nack6( tNode* pNode, UINT32 seqn, int nPayload, BOOL fSendNow ) { /* send NACK REASON_6:"Payload Corrupted" */ IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader]; IAnnexENAckReason6 reason[sizeof_IAnnexENAckReason6]; msaPrintFormat( pNode->pAnnexE->msaType, "Send NAck6(Payload corrupted, Id=%i, SEQN=%i) to Host(%08x:%i)", nPayload, seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort ); header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0; /* header.Header.T = 0; header.Header.A = 0; header.Header.S = 0; header.Header.RES = 0; */ header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck; hton16( 1, &header[IAnnexET00NAckHeader_NACK_COUNT] ); hton24( seqn, &reason[IAnnexENAckReason6_SEQNUM] ); reason[IAnnexENAckReason6_DATA_LENGTH] = 1; hton16( 6, &reason[IAnnexENAckReason6_REASON] ); reason[IAnnexENAckReason6_PAYLOAD_NUMBER] = (BYTE)nPayload; send_payload( pNode, header, sizeof_IAnnexET00NAckHeader, reason, sizeof_IAnnexENAckReason6, NULL, 0, FALSE, FALSE, fSendNow ); }
void send_nack4( tNode* pNode, UINT32 seqn, int static_type, BOOL fSendNow ) { /* send NACK REASON_4:"Static-payload type not supported" */ IAnnexET00NAckHeader header[sizeof_IAnnexET00NAckHeader]; IAnnexENAckReason4 reason[sizeof_IAnnexENAckReason4]; msaPrintFormat( pNode->pAnnexE->msaType, "Send NAck4(Static-payload-type=%i not supported, SEQN=%i) to Host(%08x:%i)", static_type, seqn, pNode->RemoteHost.nIP, pNode->RemoteHost.nPort ); header[IAnnexET00NAckHeader_Header+IAnnexET00Header_PFLAGS] = 0; /* header.Header.T = 0; header.Header.A = 0; header.Header.S = 0; header.Header.RES = 0; */ header[IAnnexET00NAckHeader_Header+IAnnexET00Header_TRANSPORT_TYPE] = AEPT00_NAck; hton16( 1, &header[IAnnexET00NAckHeader_NACK_COUNT] ); hton24( seqn, &reason[IAnnexENAckReason4_SEQNUM] ); reason[IAnnexENAckReason4_DATA_LENGTH] = 1; hton16( 4, &reason[IAnnexENAckReason4_REASON] ); reason[IAnnexENAckReason4_STATIC_TYPE] = (BYTE)static_type; send_payload( pNode, header, sizeof_IAnnexET00NAckHeader, reason, sizeof_IAnnexENAckReason4, NULL, 0, FALSE, FALSE, fSendNow ); }
// Exploit libsysutils FrameworkListener::dispatchCommand method int do_fault() { return send_payload(update_payload()); }
static void send_attr_resp_header(uint16_t attr, uint8_t type) { send_16(attr); send_payload(STATUS_SUCCESS); send_payload(type); }
static void send_cmd_status(uint16_t attr, uint8_t status) { send_16(attr); send_payload(status); }
/* continuously reads messages from UDP port */ static void *reader(UNUSED void *args) { DataPayload *dp; char buf[10240]; struct sockaddr_in c_addr; socklen_t len; int n; debugf("reader thread started\n"); for(;;) { unsigned short cmd; unsigned long sb; unsigned long seqno; unsigned char fnum; unsigned char nfrags; char *sp; unsigned short pt; RpcEndpoint ep; CRecord *cr; len = sizeof(c_addr); memset(&c_addr, 0, len); n = recvfrom(my_sock, buf, sizeof(buf), 0, (struct sockaddr *)&c_addr, &len); if (n < 0) continue; buf[n] = '\0'; dp = (DataPayload *)buf; cmd = ntohs(dp->hdr.command); sb = ntohl(dp->hdr.subport); seqno = ntohl(dp->hdr.seqno); fnum = dp->hdr.fnum; nfrags = dp->hdr.nfrags; sp = inet_ntoa(c_addr.sin_addr); pt = ntohs(c_addr.sin_port); if (cmd >= CMD_LOW && cmd <= CMD_HIGH) { logf("%s from %s:%05u:%08lx; seqno = %ld, frag/nfrag = %u/%u\n", cmdnames[cmd], sp, pt, sb, seqno, fnum, nfrags); } else { errorf("Illegal command received: %d\n", cmd); continue; } endpoint_complete(&ep, &c_addr, sb); ctable_lock(); cr = ctable_look_ep(&ep); switch (cmd) { case CONNECT: { RpcEndpoint *nep; ConnectPayload *conp = (ConnectPayload *)dp; ControlPayload *p; int newcr = 0; SRecord *sr; sr = stable_lookup(conp->sname); if (sr == NULL) break; if (cr == NULL) { nep = endpoint_duplicate(&ep); cr = crecord_create(nep, seqno); crecord_setCID(cr, gen_conn_id()); newcr = 1; } else if (cr->state != ST_IDLE) { fprintf(stderr, "%s from %s:%05u:%08lx; seqno = %ld, frag/nfrag = %u/%u\n", cmdnames[cmd], sp, pt, sb, seqno, fnum, nfrags); crecord_dump(cr, "connectrqst"); } if (newcr || cr->state == ST_IDLE) { if (newcr) { p = (ControlPayload *)malloc(CP_SIZE); cp_complete(p, nep->subport, CACK, seqno, 1, 1); crecord_setPayload(cr, p, CP_SIZE, ATTEMPTS, TICKS); } crecord_setService(cr, sr); (void) send_payload(cr->ep, cr->pl, cr->size); crecord_setState(cr, ST_IDLE); } if (newcr) ctable_insert(cr); break; } case CACK: { if ((cr != NULL)) { if (seqno == cr->seqno) crecord_setState(cr, ST_IDLE); } break; } #define NEW 2 #define OLD 1 #define ILL 0 case QUERY: { DataPayload *p = NULL; ControlPayload *cp = NULL; int dplen, cplen; unsigned long state; int accept = ILL; if (cr == NULL) break; state = cr->state; if ((seqno - cr->seqno) == 1 && (state == ST_IDLE || state == ST_RESPONSE_SENT)) { accept = NEW; cr->seqno = seqno; p = (DataPayload *)malloc(n); dplen = n; memcpy(p, buf, n); } else if (seqno == cr->seqno && state == ST_FACK_SENT && (fnum - cr->lastFrag) == 1 && fnum == nfrags) { void *tp; unsigned short flen = ntohs(dp->dhdr.flen); accept = NEW; p = (DataPayload *)cr->resp; dplen = sizeof(PayloadHeader) + sizeof(DataHeader) + ntohs(dp->dhdr.tlen); cr->resp = NULL; tp = (void *)&(p->data[FR_SIZE * (fnum - 1)]); memcpy(tp, dp->data, flen); } else if (seqno == cr->seqno && (state == ST_QACK_SENT || state == ST_RESPONSE_SENT)) { accept = OLD; } switch (accept) { case NEW: cplen = CP_SIZE; cp = (ControlPayload *)malloc(cplen); cp_complete(cp, ep.subport, QACK, seqno, fnum, nfrags); crecord_setPayload(cr, cp, cplen, ATTEMPTS, TICKS); (void)send_payload(cr->ep, cp, cplen); tsl_append(cr->svc->s_queue, cr->ep, p, dplen); crecord_setState(cr, ST_QACK_SENT); break; case OLD: (void)send_payload(cr->ep, cr->pl, cr->size); crecord_setState(cr, state); break; case ILL: break; } break; } case QACK: { if (cr != NULL) { if (seqno == cr->seqno) crecord_setState(cr, ST_AWAITING_RESPONSE); } break; } case RESPONSE: { DataPayload *p = NULL; ControlPayload *cp = NULL; int cplen; unsigned long st; unsigned short flen = ntohs(dp->dhdr.flen); if (cr == NULL || seqno != cr->seqno) break; st = cr->state; if (st == ST_QUERY_SENT || st == ST_AWAITING_RESPONSE) { p = (DataPayload *)malloc(n); memcpy(p, buf, n); cr->resp = p; } else if (st == ST_FACK_SENT && (fnum - cr->lastFrag) == 1 && fnum == nfrags) { p = (DataPayload *)cr->resp; memcpy(&(p->data[FR_SIZE * (fnum -1)]), dp->data, flen); cr->lastFrag = fnum; } else break; cplen = CP_SIZE; cp = (ControlPayload *)malloc(cplen); cp_complete(cp, ep.subport, RACK, seqno, fnum, nfrags); crecord_setPayload(cr, cp, cplen, ATTEMPTS, TICKS); (void)send_payload(cr->ep, cp, cplen); crecord_setState(cr, ST_IDLE); break; } case RACK: { if (cr != NULL) { if (seqno == cr->seqno) crecord_setState(cr, ST_IDLE); } break; } case DISCONNECT: { ControlPayload cp; /* always send a DACK */ cp_complete(&cp, ep.subport, DACK, seqno, 1, 1); (void)send_payload(&ep, &cp, CP_SIZE); if (cr != NULL) { crecord_setState(cr, ST_TIMEDOUT); } break; } case DACK: { if (cr != NULL) { if (seqno == cr->seqno) crecord_setState(cr, ST_TIMEDOUT); } break; } case FRAGMENT: { DataPayload *p = NULL; ControlPayload *cp = NULL; int dplen, cplen; unsigned long st; int accept = ILL; unsigned short tlen = ntohs(dp->dhdr.tlen); unsigned short flen = ntohs(dp->dhdr.flen); int isQ, isR; if (cr == NULL) break; st = cr->state; isQ = (st == ST_IDLE || st == ST_RESPONSE_SENT) && (seqno - cr->seqno) == 1 && fnum == 1; isR = (st == ST_QUERY_SENT || st == ST_AWAITING_RESPONSE) && seqno == cr->seqno && fnum == 1; if (isQ || isR) { accept = NEW; cr->seqno = seqno; dplen = sizeof(PayloadHeader) + sizeof(DataHeader) + tlen; cr->resp = malloc(dplen); p = (DataPayload *)cr->resp; memcpy(p, buf, n); } else if (seqno == cr->seqno && st == ST_FACK_SENT && (fnum - cr->lastFrag) == 1) { void *tp; accept = NEW; p = (DataPayload *)cr->resp; tp = (void *)&(p->data[FR_SIZE * (fnum - 1)]); memcpy(tp, dp->data, flen); } else if (seqno == cr->seqno && st == ST_FACK_SENT && fnum == cr->lastFrag) { accept = OLD; } switch (accept) { case NEW: cr->lastFrag = fnum; cplen = CP_SIZE; cp = (ControlPayload *)malloc(cplen); cp_complete(cp, ep.subport, FACK, seqno, fnum, nfrags); crecord_setPayload(cr, cp, cplen, ATTEMPTS, TICKS); (void)send_payload(cr->ep, cp, cplen); crecord_setState(cr, ST_FACK_SENT); break; case OLD: (void)send_payload(cr->ep, cr->pl, cr->size); crecord_setState(cr, st); break; case ILL: break; } break; } case FACK: { if (cr != NULL) { if (seqno == cr->seqno && cr->state == ST_FRAGMENT_SENT && fnum == cr->lastFrag) { crecord_setState(cr, ST_FACK_RECEIVED); } } break; } case PING: { ControlPayload cp; if (cr != NULL) { cp_complete(&cp, ep.subport, PACK, seqno, 1, 1); (void)send_payload(&ep, &cp, CP_SIZE); } break; } case PACK: { if (cr != NULL) { crecord_setState(cr, cr->state); /* resets ping data */ } break; } case SEQNO: { ControlPayload *cp; if (cr != NULL) { unsigned long st = cr->state; if (st == ST_IDLE || st == ST_RESPONSE_SENT) { cp = (ControlPayload *)malloc(CP_SIZE); cp_complete(cp, ep.subport, SACK, seqno, 1, 1); crecord_setPayload(cr, cp, CP_SIZE, ATTEMPTS, TICKS); (void)send_payload(cr->ep, cp, CP_SIZE); cr->seqno = seqno; crecord_setState(cr, ST_IDLE); } } break; } case SACK: { if (cr != NULL && cr->state == ST_SEQNO_SENT) { crecord_setState(cr, ST_IDLE); } break; } default: { break; } } ctable_unlock(); } return NULL; }
static bool process_read_cmd() { send_zcl_header(CMDID_READ_RESPONSE); while(msg_available()) { uint16_t attr; attr = msg_get_16(); if (zcl.packet.cluster == CLUSTERID_BASIC) { switch(attr) { case ATTR_DEVICE_ENABLED: send_attr_resp_header(ATTR_DEVICE_ENABLED, TYPE_BOOLEAN); send_payload(get_mode()); break; case ATTR_ALARM_MASK: send_attr_resp_header(ATTR_ALARM_MASK, TYPE_BOOLEAN); send_payload(0); //FIXME: implement break; default: send_cmd_status(attr, STATUS_UNSUPPORTED_ATTRIBUTE); break; } } else if (zcl.packet.cluster == CLUSTERID_ELOVALO) { switch(attr) { case ATTR_IEEE_ADDRESS: { send_attr_resp_header(ATTR_IEEE_ADDRESS, TYPE_IEEE_ADDRESS); send_64(mac); break; } case ATTR_OPERATING_MODE: { send_attr_resp_header(ATTR_OPERATING_MODE, TYPE_ENUM); send_payload(get_mode()); break; } case ATTR_EFFECT_TEXT: send_cmd_status(ATTR_EFFECT_TEXT, STATUS_WRITE_ONLY); break; case ATTR_PLAYLIST: send_attr_resp_header(ATTR_PLAYLIST, TYPE_UINT8); send_payload(read_playlist()); break; case ATTR_TIMEZONE: send_attr_resp_header(ATTR_TIMEZONE, TYPE_INT32); send_i32(get_timezone()); break; case ATTR_TIME: send_attr_resp_header(ATTR_TIME, TYPE_UTC_TIME); send_32(time(NULL)-ZIGBEE_TIME_OFFSET); break; case ATTR_EFFECT_NAMES: send_attr_resp_header(ATTR_EFFECT_NAMES, TYPE_LONG_OCTET_STRING); send_effect_names(); break; case ATTR_PLAYLIST_NAMES: send_attr_resp_header(ATTR_PLAYLIST_NAMES, TYPE_LONG_OCTET_STRING); send_16(playlists_json_len); send_pgm_string_direct(playlists_json); break; case ATTR_PLAYLIST_EFFECTS: { send_attr_resp_header(ATTR_PLAYLIST_EFFECTS, TYPE_OCTET_STRING); // current playlist index uint8_t pl_begin = pgm_get(playlists[active_playlist], byte); // End index to playlist, not included to playlist uint8_t pl_end; if (active_playlist == playlists_len - 1) { pl_end = master_playlist_len; } else { pl_end = pgm_get(playlists[active_playlist + 1], byte); } //Send string length send_payload(pl_end - pl_begin); for (uint8_t i = pl_begin; i < pl_end; i++) { send_payload(pgm_get(master_playlist[i].id, byte)); //send_payload(i); } break; } case ATTR_EFFECT: send_attr_resp_header(ATTR_EFFECT, TYPE_UINT8); send_payload(read_effect()); break; case ATTR_HW_VERSION: send_attr_resp_header(ATTR_HW_VERSION, TYPE_OCTET_STRING); send_local_pgm_str(hw_resp); break; case ATTR_SW_VERSION: send_attr_resp_header(ATTR_SW_VERSION, TYPE_OCTET_STRING); send_local_pgm_str(sw_resp); break; case ATTR_PLAYLIST_POSITION: send_attr_resp_header(ATTR_PLAYLIST_POSITION, TYPE_UINT8); uint8_t start = pgm_get(playlists[active_playlist],byte); send_payload(active_effect-start); break; default: send_cmd_status(attr, STATUS_UNSUPPORTED_ATTRIBUTE); break; } } else { // FIXME: See if correct way to handle incorrect cluster if (!zcl.packet.disable_def_resp) { send_default_response(CMDID_READ, STATUS_UNSUP_CLUSTER_COMMAND); } return true; } } return true; }
int rpc_call(RpcConnection rpc, const struct qdecl *q, unsigned qlen, void *resp, unsigned rsize, unsigned *rlen) { DataPayload *buf; RpcEndpoint *ep; unsigned short size = sizeof(PayloadHeader) + sizeof(DataHeader) + qlen; unsigned long seqno; unsigned long qstates[2] = {ST_IDLE, ST_TIMEDOUT}; unsigned long fstates[2] = {ST_FACK_RECEIVED, ST_TIMEDOUT}; int result = 0; CRecord *cr; unsigned char fnum; unsigned char nfrags; unsigned blen; unsigned char *cp = (unsigned char *)q->buf; if (q->size < (int)qlen) { fprintf(stderr, "rpc_call() - buffer overrun by caller\n"); return result; } ctable_lock(); if ((cr = ctable_look_id((unsigned long)rpc)) == NULL) { ctable_unlock(); return result; } ep = cr->ep; if (cr->state == ST_IDLE) { if (cr->seqno >= SEQNO_LIMIT) { ControlPayload *cp; cr->seqno = SEQNO_START; cp = (ControlPayload *)malloc(CP_SIZE); cp_complete(cp, ep->subport, SEQNO, SEQNO_START, 1, 1); crecord_setPayload(cr, cp, CP_SIZE, ATTEMPTS, TICKS); (void)send_payload(ep, cp, CP_SIZE); crecord_setState(cr, ST_SEQNO_SENT); if (crecord_waitForState(cr, qstates, 2) == ST_TIMEDOUT) { ctable_unlock(); return result; } } cr->seqno++; seqno = cr->seqno; nfrags = (qlen - 1) / FR_SIZE + 1; for (fnum = 1; fnum < nfrags; fnum++) { size = sizeof(PayloadHeader) + sizeof(DataHeader) + FR_SIZE; buf = (DataPayload *)malloc(size); cp_complete((ControlPayload *)buf, ep->subport, FRAGMENT, seqno, fnum, nfrags); buf->dhdr.tlen = htons(qlen); buf->dhdr.flen = htons(FR_SIZE); memcpy(buf->data, &(cp[FR_SIZE*(fnum-1)]), FR_SIZE); cr->lastFrag = fnum; crecord_setPayload(cr, buf, size, ATTEMPTS, TICKS); (void)send_payload(ep, buf, size); crecord_setState(cr, ST_FRAGMENT_SENT); if (crecord_waitForState(cr, fstates, 2) == ST_TIMEDOUT) { ctable_unlock(); return result; } } blen = qlen - FR_SIZE * (nfrags - 1); size = sizeof(PayloadHeader) + sizeof(DataHeader) + blen; buf = (DataPayload *)malloc(size); cp_complete((ControlPayload *)buf, ep->subport, QUERY, seqno, fnum, nfrags); buf->dhdr.tlen = htons(qlen); buf->dhdr.flen = htons(blen); memcpy(buf->data, &(cp[FR_SIZE*(fnum-1)]), blen); crecord_setPayload(cr, buf, size, ATTEMPTS, TICKS); (void)send_payload(ep, buf, size); crecord_setState(cr, ST_QUERY_SENT); if (crecord_waitForState(cr, qstates, 2) == ST_TIMEDOUT) { ctable_unlock(); return result; } buf = (DataPayload *)cr->resp; cr->resp = NULL; if (cr->state == ST_IDLE) { size = ntohs(buf->dhdr.tlen); if (size <= rsize) { memcpy(resp, buf->data, size); *rlen = size; result = 1; } else result = 0; } free(buf); } ctable_unlock(); return result; }
RVAPI annexEStatus RVCALLCONV annexESendMessage( IN HANNEXE hAnnexE, IN UINT32 ip, IN UINT16 port, IN UINT16 CRV, IN void* message, IN int size, IN BOOL fAckHint, IN BOOL fReplyHint, IN BOOL fSendHint ) { tAnnexE *pAnnexE = AsAnnexE( hAnnexE ); tNode *pNode; if (!pAnnexE) return annexEStatusBadParameter; pNode = get_node( pAnnexE, ip, port ); if (pNode == NULL) { pNode = add_node( pAnnexE, ip, port ); } if (pNode == NULL) { msaPrintFormat( pAnnexE->msaType, "annexESendMessage() - annexEStatusResourceProblem!" ); return annexEStatusResourceProblem; } if (pNode->fLocalAddressUsed) { IAnnexET10PayloadSA pheader[sizeof_IAnnexET10PayloadSA_ND]; pheader[IAnnexET10PayloadSA_Header + IAnnexET10Header_PFLAGS] = AEP_MASK_A | AEP_MASK_S | (AEPT_StaticMessage << AEP_SHFT_T); /* pheader.Header.A = 1; pheader.Header.S = 1; pheader.Header.RES = 0; pheader.Header.T = AEPT_StaticMessage; */ pheader[IAnnexET10PayloadSA_Header + IAnnexET10Header_STATIC_TYPE] = 0; /* h.225 messages */ hton32( pNode->nLocalAddress, &pheader[IAnnexET10PayloadSA_ADDRESS] ); hton16( CRV, &pheader[IAnnexET10PayloadSA_SESSION] ); hton16( (UINT16)size, &pheader[IAnnexET10PayloadSA_DATA_LENGTH] ); if (send_payload( pNode, pheader, sizeof_IAnnexET10PayloadSA_ND, message, size, NULL, 0, fAckHint, fReplyHint, fSendHint )) { return annexEStatusNormal; } else { return annexEStatusWouldBlock; } } else { IAnnexET10PayloadS pheader[sizeof_IAnnexET10PayloadS_ND]; pheader[IAnnexET10PayloadS_Header + IAnnexET10Header_PFLAGS] = AEP_MASK_S | (AEPT_StaticMessage << AEP_SHFT_T); /* pheader.Header.A = 0; pheader.Header.S = 1; pheader.Header.RES = 0; pheader.Header.T = AEPT_StaticMessage; */ pheader[IAnnexET10PayloadS_Header + IAnnexET10Header_STATIC_TYPE] = 0; /* h.225 messages */ hton16( CRV, &pheader[IAnnexET10PayloadS_SESSION] ); hton16( (UINT16)size, &pheader[IAnnexET10PayloadS_DATA_LENGTH] ); if (send_payload( pNode, pheader, sizeof_IAnnexET10PayloadS_ND, message, size, NULL, 0, fAckHint, fReplyHint, fSendHint )) { return annexEStatusNormal; } else { return annexEStatusWouldBlock; } } }
BOOL send_payload( tNode* pNode, void* payload_header, int payload_header_size, void* payload_data, int payload_data_size, void* payload_exdata, int payload_exdata_size, BOOL AckFlag, BOOL HFlag, BOOL SendNow ) { tPDU* pCurrentPDU; BOOL fFirstPayload = FALSE; /* if can't send add to the list of pended nodes */ if (AckFlag && (pNode->pWaitingForAckPDU != NULL)) { return FALSE; } /* get free PDU if needed */ if (pNode->pCurrentPDU == NULL) { PLIST_ENTRY plink; if (IsListEmpty( &pNode->pAnnexE->FreePDUList )) { InsertTailList( &pNode->pAnnexE->ResBlockedNodeList, &pNode->lPendLink ); return FALSE; } fFirstPayload = TRUE; plink = RemoveHeadList( &pNode->pAnnexE->FreePDUList ); pNode->pCurrentPDU = CONTAINING_RECORD( plink, tPDU, lPDULink ); pCurrentPDU = pNode->pCurrentPDU; pCurrentPDU->nIP = pNode->RemoteHost.nIP; pCurrentPDU->nPort = pNode->RemoteHost.nPort; pCurrentPDU->PDU[IAnnexEHeader_FLAGS] = 0; hton24( get_next_seqn( pNode ), &pCurrentPDU->PDU[IAnnexEHeader_SEQN] ); pCurrentPDU->nSize = sizeof_IAnnexEHeader; if (payload_header_size + payload_data_size + payload_exdata_size >= (pCurrentPDU->nMaxSize - pCurrentPDU->nSize)) { RV_ASSERT( FALSE ); /* this is serious APPLICATION bug (payload is greather than PDU size)!!! */ return FALSE; } } else pCurrentPDU = pNode->pCurrentPDU; /* check for free space in PDU */ if (payload_header_size + payload_data_size + payload_exdata_size < (pCurrentPDU->nMaxSize - pCurrentPDU->nSize)) { /* append payload to the PDU */ if (payload_header_size > 0) { memcpy( &pCurrentPDU->PDU[pCurrentPDU->nSize], payload_header, payload_header_size ); pCurrentPDU->nSize += payload_header_size; } if (payload_data_size > 0) { memcpy( &pCurrentPDU->PDU[pCurrentPDU->nSize], payload_data, payload_data_size ); pCurrentPDU->nSize += payload_data_size; } if (payload_exdata_size > 0) { memcpy( &pCurrentPDU->PDU[pCurrentPDU->nSize], payload_exdata, payload_exdata_size ); pCurrentPDU->nSize += payload_exdata_size; } AEHOr_A( pCurrentPDU->PDU, AckFlag ); AEHOr_H( pCurrentPDU->PDU, HFlag ); if ( (SendNow) && (!pNode->fDontSend) ) { send_current_pdu( pNode ); } return TRUE; } else { /* no place for that payload => send current PDU! */ send_current_pdu( pNode ); if (AckFlag && (pNode->pWaitingForAckPDU != NULL)) return FALSE; else return send_payload( pNode, payload_header, payload_header_size, payload_data, payload_data_size, payload_exdata, payload_exdata_size, AckFlag, HFlag, SendNow ); } }