/** * Transmit the start message to the DV service. * * @param cls the `struct GNUNET_DV_ServiceHandle *` * @param size number of bytes available in buf * @param buf where to copy the message * @return number of bytes written to buf */ static size_t transmit_start (void *cls, size_t size, void *buf) { struct GNUNET_DV_ServiceHandle *sh = cls; struct GNUNET_MessageHeader start_message; sh->th = NULL; if (NULL == buf) { GNUNET_break (0); reconnect (sh); return 0; } GNUNET_assert (size >= sizeof (start_message)); start_message.size = htons (sizeof (struct GNUNET_MessageHeader)); start_message.type = htons (GNUNET_MESSAGE_TYPE_DV_START); memcpy (buf, &start_message, sizeof (start_message)); LOG (GNUNET_ERROR_TYPE_DEBUG, "Transmitting START request, starting receive loop for %p\n", sh->client); GNUNET_CLIENT_receive (sh->client, &handle_message_receipt, sh, GNUNET_TIME_UNIT_FOREVER_REL); start_transmit (sh); return sizeof (start_message); }
/** * Send a message via DV service. * * @param sh service handle * @param target intended recpient * @param msg message payload * @param cb function to invoke when done * @param cb_cls closure for @a cb * @return handle to cancel the operation */ struct GNUNET_DV_TransmitHandle * GNUNET_DV_send (struct GNUNET_DV_ServiceHandle *sh, const struct GNUNET_PeerIdentity *target, const struct GNUNET_MessageHeader *msg, GNUNET_DV_MessageSentCallback cb, void *cb_cls) { struct GNUNET_DV_TransmitHandle *th; struct GNUNET_DV_SendMessage *sm; struct ConnectedPeer *peer; if (ntohs (msg->size) + sizeof (struct GNUNET_DV_SendMessage) >= GNUNET_SERVER_MAX_MESSAGE_SIZE) { GNUNET_break (0); return NULL; } LOG (GNUNET_ERROR_TYPE_DEBUG, "Asked to send %u bytes of type %u to %s via %p\n", (unsigned int) ntohs (msg->size), (unsigned int) ntohs (msg->type), GNUNET_i2s (target), sh->client); peer = GNUNET_CONTAINER_multipeermap_get (sh->peers, target); if (NULL == peer) { GNUNET_break (0); return NULL; } th = GNUNET_malloc (sizeof (struct GNUNET_DV_TransmitHandle) + sizeof (struct GNUNET_DV_SendMessage) + ntohs (msg->size)); th->sh = sh; th->target = peer; th->cb = cb; th->cb_cls = cb_cls; th->msg = (const struct GNUNET_MessageHeader *) &th[1]; sm = (struct GNUNET_DV_SendMessage *) &th[1]; sm->header.type = htons (GNUNET_MESSAGE_TYPE_DV_SEND); sm->header.size = htons (sizeof (struct GNUNET_DV_SendMessage) + ntohs (msg->size)); if (0 == sh->uid_gen) sh->uid_gen = 1; th->uid = sh->uid_gen; sm->uid = htonl (sh->uid_gen++); /* use memcpy here as 'target' may not be sufficiently aligned */ memcpy (&sm->target, target, sizeof (struct GNUNET_PeerIdentity)); memcpy (&sm[1], msg, ntohs (msg->size)); GNUNET_CONTAINER_DLL_insert_tail (sh->th_head, sh->th_tail, th); start_transmit (sh); return th; }
void rt_task4_thread_entry(void* parameter) { extern void start_transmit(void); extern void stop_transmit(void); extern uint8_t check_parameter(void); // extern uint8_t self_check(void); // extern void cpu_usage_init(); rt_uint32_t ev; if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0)) { coil.usRegCoilBuf |= M(0); } else { coil.usRegCoilBuf &= ~M(0); } rt_event_init(&key_event, "key_event", RT_IPC_FLAG_FIFO ); while(1) { if( rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, RT_WAITING_FOREVER, &ev ) == RT_EOK ) { rt_thread_delay(6); if( (ev & FOOT_PUPD) && (coil.usRegCoilBuf & M(0)) &&(GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0) == 0)&& \ (check_parameter()) && (coil.usRegCoilBuf & M(7))) { start_transmit(); } else { stop_transmit(); } if(ev & KEY_PUPD) { if((GPIO_ReadInputDataBit(GPIOD, GPIO_Pin_3) == 0)) { coil.usRegCoilBuf |= M(0); } else { coil.usRegCoilBuf &= ~M(0); } } } rt_event_recv( &key_event, FOOT_PUPD | KEY_PUPD, RT_EVENT_FLAG_OR | RT_EVENT_FLAG_CLEAR, 2, &ev ); rt_thread_delay(20); } }
/** * Gives a message from our queue to the DV service. * * @param cls handle to the dv service (`struct GNUNET_DV_ServiceHandle`) * @param size how many bytes can we send * @param buf where to copy the message to send * @return how many bytes we copied to @a buf */ static size_t transmit_pending (void *cls, size_t size, void *buf) { struct GNUNET_DV_ServiceHandle *sh = cls; char *cbuf = buf; struct GNUNET_DV_TransmitHandle *th; size_t ret; size_t tsize; sh->th = NULL; if (NULL == buf) { reconnect (sh); return 0; } ret = 0; while ( (NULL != (th = sh->th_head)) && (size - ret >= (tsize = ntohs (th->msg->size)) )) { GNUNET_CONTAINER_DLL_remove (sh->th_head, sh->th_tail, th); memcpy (&cbuf[ret], th->msg, tsize); LOG (GNUNET_ERROR_TYPE_DEBUG, "Passing %u bytes of type %u to DV service\n", tsize, ntohs (th->msg->type)); th->msg = NULL; ret += tsize; if (NULL != th->cb) { GNUNET_CONTAINER_DLL_insert_tail (th->target->head, th->target->tail, th); } else { GNUNET_free (th); } } if (NULL != sh->th_head) start_transmit (sh); return ret; }