void Master::server_notify(pair <int, int> srv, bool extension) //notify server of server fail/chain extension { Server *prev = Search_Prev_Server(srv, !extension); cal_next(srv.first); if (prev == NULL) { printf("Head server fails, the successor automatically becomes the new head\n"); return; } else { //printf("previous server is %d\n", prev->GetserverName().second); socklen_t len = sizeof(sockaddr_in); char send_msg[MAXLINE]; Server *next = Search_Next_Server(prev); if (next == NULL) { srv.second = -1; } else { srv.second = next->GetserverName().second; } packetize(send_msg, srv, false, extension); Sendto(sockfd_udp, send_msg, MAXLINE, 0, (SA*)&(prev->Getsockaddr()), len); if (extension) printf("New server extended to the tail of chain %d\n%s\n", srv.first, seperator); else if (srv.second == -1) printf("Tail server fails, server notification sent out to its precessor: 127.0.0.1:%d\n", prev->GetserverName().second); else printf("Internal server fails, server notification sent out to its precessor: 127.0.0.1:%d, new next server is 127.0.0.1:%d\n", prev->GetserverName().second, srv.second); } }
/* * * THIS FUNCTION WAS FUNCTIONALY REPLACED WITH playwav() * */ int UDPsend(UDPinfo *UI, TCPinfo *TI) { WSABUF filecontents; DWORD bytetoSend; DWORD flags = 0; FILE *fp; int byteSent = 0; int bufpos = 0; int numpackets; memset((void *)&UI->WH, 0, sizeof(wavheader)); filecontents.buf = (char *) malloc (BUFSIZE); filecontents.buf = UI->WH.soundBuffer; filecontents.len = BUFSIZE; numpackets = (UI->WH.dataSize / BUFSIZE); bytetoSend = (numpackets * SOUND_DATA_SIZE)+(numpackets * 44);// do math for this ...soundbuffer/512 then add header to each of those TCPcontrolsend(TI, UI, UI->WH.size); while(bytetoSend > byteSent) { filecontents.buf = packetize(&UI->WH, &bufpos); byteSent += sendto(UI->sd, filecontents.buf, BUFSIZE, flags, (struct sockaddr *)&UI->server, UI->server_len); } return 0; }
/* * Send a message via RTP using the connection information * given on UDP socket functions sendto() and recvfrom() */ int rtp_send_message(CONN_INFO *connection, MESSAGE* msg){ /* ---- FIXME ---- * The goal of this function is to turn the message buffer * into packets and then, using stop-n-wait RTP protocol, * send the packets and re-send if the response is a NACK. * If the response is an ACK, then you may send the next one */ int* packetCount = malloc(sizeof(int)); PACKET* packets = packetize(msg->buffer, msg->length, packetCount); int i =0; do{ sendto(connection->socket, (void*)(packets+i), sizeof(PACKET), 0 , connection->remote_addr, connection->addrlen); PACKET* response = malloc(sizeof(PACKET)); recvfrom(connection->socket, (void*)response, sizeof(PACKET), 0, connection->remote_addr , &(connection->addrlen)); if(response->type==ACK){ if(packets[i].type==LAST_DATA){ break; } i++; } free(response); }while(i< *packetCount); free(packets); return 0; }
static int packetize_annexb(uint64_t rtp_ts, const uint8_t *buf, size_t len, size_t pktsize, videnc_packet_h *pkth, void *arg) { const uint8_t *start = buf; const uint8_t *end = buf + len; const uint8_t *r; int err = 0; r = h265_find_startcode(start, end); while (r < end) { const uint8_t *r1; bool marker; /* skip zeros */ while (!*(r++)) ; r1 = h265_find_startcode(r, end); marker = (r1 >= end); err |= packetize(marker, r, r1-r, pktsize, rtp_ts, pkth, arg); r = r1; } return err; }
/* * Send a message via RTP using the connection information * given on UDP socket functions sendto() and recvfrom() */ int rtp_send_message(CONN_INFO *connection, MESSAGE*msg){ /* ---- FIXME ---- * The goal of this function is to turn the message buffer * into packets and then, using stop-n-wait RTP protocol, * send the packets and re-send if the response is a NACK. * If the response is an ACK, then you may send the next one */ int count = 0; PACKET* packets = packetize(msg->buffer, msg->length, &count); for (int i = 0; i < count; i++) { sendto(connection->socket, (packets + i), sizeof(PACKET), 0, connection->remote_addr, connection->addrlen); int ack = 0; PACKET *response = (PACKET*)malloc(sizeof(PACKET)); // Wait until an ACK is received, else resend the packet (Stop & Wait Implementation) while (ack == 0) { // Receive packet from connection recvfrom(connection->socket, response, sizeof(PACKET), 0, connection->remote_addr, &connection->addrlen); // Positive ACK packet if (response->type == ACK) { ack = 1; } // Negative ACK packet else if (response->type == NACK) { ack = 2; i -= 1; } } } return 1; }
unsigned char *get_hub_query_cmd(size_t byte_count, size_t *buf_size) { unsigned char hub_query_cmd[] = { 0x01, 0x85, 0xf0, 0x10, 0x8f, 0x30, 0x0e, 0x00, 0x60, 0x82, 0x10, 0xde, 0x01, 0x81, 0x30, 0x8f, 0x30, 0x0c, 0x00, 0x60, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0x80, 0xa2, 0x00, 0x00, 0x81, 0x30, 0x82, 0x10, 0x43, 0x00, 0xc0, 0xa2, 0x00, 0x00, 0x81, 0x30, }; size_t len = sizeof(hub_query_cmd) / sizeof(*hub_query_cmd); *buf_size = packet_size(len); return packetize(hub_query_cmd, len, 1); }
size_t bus_i2c::write_bytes(int addr, unsigned int size, uint8_t index, uint8_t* data){ // Container i2c_bus_packet_t packet; /* * Packetize */ packetize(size, index, data, &packet); /* * Write and return the size written */ return write(addr, &packet); }
void Connection::onRecvCompleted(const asio::error_code& e, std::size_t bytes_transferred) { if ( e ) { m_socket.close(); onError(e); return; } if ( bytes_transferred > 0 ) { m_recvBuf.write( m_buffer.data(), bytes_transferred ); packetize(); } requestRecv(); }
/* * Send a message via RTP using the connection information * given on UDP socket functions sendto() and recvfrom() */ int rtp_send_message(CONN_INFO *connection, MESSAGE *msg) { /* ---- FIXME ---- * The goal of this function is to turn the message buffer * into packets and then, using stop-n-wait RTP protocol, * send the packets and re-send if the response is a NACK. * If the response is an ACK, then you may send the next one */ int count = 0; int num = 0; PACKET* packet = packetize(msg->buffer, msg->length, &count); while (num < count) { sendto(connection->socket, &(packet[num]), sizeof(PACKET), 0, connection->remote_addr, connection->addrlen); PACKET* back = malloc(sizeof(PACKET)); recvfrom(connection->socket, back, sizeof(PACKET), 0, connection->remote_addr, &connection->addrlen); if (back->type == ACK) { num++; } } return 0; }
int h265_encode(struct videnc_state *st, bool update, const struct vidframe *frame, videnc_packet_h *pkth, void *arg) { x265_picture *pic_in = NULL, pic_out; x265_nal *nalv; uint32_t i, nalc = 0; int n, err = 0; if (!st || !frame || !pkth || frame->fmt != VID_FMT_YUV420P) return EINVAL; if (!st->x265 || !vidsz_cmp(&st->size, &frame->size)) { err = open_encoder(st, &frame->size); if (err) return err; st->size = frame->size; } if (update) { debug("h265: encode: picture update was requested\n"); } pic_in = x265_picture_alloc(); if (!pic_in) { warning("h265: x265_picture_alloc failed\n"); return ENOMEM; } x265_picture_init(st->param, pic_in); pic_in->sliceType = update ? X265_TYPE_IDR : X265_TYPE_AUTO; pic_in->pts = ++st->pts; /* XXX: add PTS to API */ pic_in->colorSpace = X265_CSP_I420; for (i=0; i<3; i++) { pic_in->planes[i] = frame->data[i]; pic_in->stride[i] = frame->linesize[i]; } /* NOTE: important to get the PTS of the "out" picture */ n = x265_encoder_encode(st->x265, &nalv, &nalc, pic_in, &pic_out); if (n <= 0) goto out; for (i=0; i<nalc; i++) { x265_nal *nal = &nalv[i]; uint8_t *p = nal->payload; size_t len = nal->sizeBytes; bool marker; #if 1 debug("h265: encode: %s type=%2d %s\n", h265_is_keyframe(nal->type) ? "<KEY>" : " ", nal->type, h265_nalunit_name(nal->type)); #endif h265_skip_startcode(&p, &len); /* XXX: use pic_out.pts */ marker = (i+1)==nalc; /* last NAL */ err = packetize(marker, p, len, st->pktsize, pkth, arg); if (err) goto out; } out: if (pic_in) x265_picture_free(pic_in); return err; }
int main(int argc, char* argv[]) { char* sender_ip; int sender_port; char* receiver_ip; int receiver_port; char* filename; FILE* file; int file_length; // Length of file in bytes char* data; // Each element is a byte from the file if(argc != 6) { printf("Usage: $./rdps sender_ip sender_port receiver_ip receiver_port sender_file_name\n"); exit(0); } sender_ip = argv[1]; sender_port = atoi(argv[2]); receiver_ip = argv[3]; receiver_port = atoi(argv[4]); filename = argv[5]; // Open file if((file = fopen(filename, "r")) == NULL) { perror("sender: open\n"); exit(-1); } // determine file size fseek(file, 0, SEEK_END); file_length = ftell(file); rewind(file); printf("file length: %d\n",file_length); data = (char*)malloc(sizeof(data)*file_length); // Read file byte by byte into data buffer if(fread(data, 1, file_length, file) != file_length) { perror("sender: fread"); free(data); exit(-1); } fclose(file); // Calculate payload size based on file length for files of size less than MAX_PAYLOAD_SIZE int payload_size = 0; int i; /* for(i=1; i<=MAX_PAYLOAD_SIZE; i++) { // found a factor if(file_length%i==0) { // if it's a greater factor if(i > payload_size) payload_size = i; } } */ payload_size = MAX_PAYLOAD_SIZE; printf("Payload size: %d\n",payload_size); // Calculate number of data packets to be stored float n = ((float)file_length) / ((float)payload_size); int num_packets = ceil(n); printf("Number of data packets: %d\n", num_packets); // Init globals data_packets = (struct packet**)calloc(num_packets+1, sizeof(struct packet*)); // print contents of data_packets for(i=0; data_packets[i] == 0; i++) { //printf("data_packets[%d] is 0\n",i); } if(data_packets[num_packets] != 0){printf("data_packets[%d] is not 0\n",num_packets);} window_size = file_length/10; printf("window size: %d\n",window_size); setup_connection(sender_ip, sender_port, receiver_ip, receiver_port); packetize(data, file_length, payload_size); initiate_transfer(file_length+payload_size-1); return 0; }