int main( ) { dp::LockObject l; dp::SyncObject s; dp::CurrentTime start; dp::CurrentTime end; { dp::Lock lock( l ); std::printf( "wait %d milli seconds\n", WAIT_MILLIS ); start.update(); lock.timedWait( s , WAIT_MILLIS ); end.update(); std::printf( "end\n" ); } std::printf( "start time:\n" ); printCurrentTime( start ); std::printf( "end time:\n" ); printCurrentTime( end ); dp::TimeDiff startToEnd( start , end ); std::printf( "start to end:\n" ); printTimeDiff( startToEnd ); dp::TimeDiff endToStart( end , start ); std::printf( "end to start:\n" ); printTimeDiff( endToStart ); return 0; }
int main (int argc, char* argv[]) { printf ("Step1\n"); try { Locale locale (CHINA); Locale::setCurrentLocale (&locale); printf ("Step4\n"); printCurrentLocaleInfo (); printCurrentTimeZoneInfo (); printCurrentTime (); printFormatTime (); } catch (Exception& e) { cout<<"Exception occurred: " << endl; } return 0; }
int receiveFileAsynchronously(int connectionId, struct packet *recvPacket) { struct list *connection = getNodeByID(connectionList, connectionId); struct host *source = (struct host *) connection->value; if (connection->filePointer == NULL) { printf("Started receiving file: %s at %s from %s/%s.\n$", recvPacket->header->fileName, printCurrentTime(), source->hostName, source->port); fflush(stdout); // Create file where data will be stored char *filename = recvPacket->header->fileName; char *tempfilename = stringConcat("./", filename); FILE *fp = fopen(tempfilename, "wb"); //for testing it should be filename if (fp == NULL) { printf("Error opening file.\n"); deletePacketAndMessage(recvPacket); return -1; } //update the File pointer to the connection connection->filePointer = fp; //write the packet received int written_bytes = fwrite(recvPacket->message, 1, recvPacket->header->length, connection->filePointer); deletePacketAndMessage(recvPacket); } else { //write the packet received int written_bytes = fwrite(recvPacket->message, 1, recvPacket->header->length, connection->filePointer); deletePacketAndMessage(recvPacket); } return 0; }
int okPacketHandler(int connectionId, struct packet *recvPacket) { struct list *connection = getNodeByID(connectionList, connectionId); struct host *source = (struct host *) connection->value; if (connection->filePointer != NULL) { //print completion of file download printf("Finished receiving file: %s at %s from %s/%s.\n", recvPacket->header->fileName, printCurrentTime(), source->hostName, source->port); //close the file pointer fclose(connection->filePointer); //make the file pointer in the connection to indicate that no file operation is in progress connection->filePointer = NULL; } return 0; }
int main() { initscr(); cbreak(); noecho(); keypad(stdscr, TRUE); //open file and write intro data to file FILE *file; file = openFile(); //collect summary data from user and write to file char *title = ""; char *desc = ""; char *loc = ""; char temp[3] = ""; //sprintf(temp,"a"); getSummary(title, desc, loc); //collect data/time data from user and write to file char *startdatetime; char *enddatetime; getDateTime(startdatetime,enddatetime); //!!!!!!remember: [date]T[time]!!!!!!!!!!!!! //clean up getch(); endwin(); //print data to file printIntro(file); printCurrentTime(file); fprintf(file,"ORGANIZER;CN=Derek Redfern:mailto:[email protected]\n\ DESCRIPTION:%s\nSUMMARY;LANGUAGE=en-us:%s\nLOCATION:%s\n",\ desc,title,loc); fprintf(file,"DTSTART;TZID=\"Eastern Standard Time\":%s\n",startdatetime); fprintf(file,"DTEND;TZID=\"Eastern Standard Time\":%s\n",enddatetime); fprintf(file,"END:VEVENT\nEND:VCALENDAR\n"); fclose(file); return 0; }
static void initGUI(int numframes, gchar *notefile) { int i = 0, transIndex = 0; GtkWidget *timeBox = NULL, *notePadBox = NULL, *notePadScroll = NULL, *table = NULL; GtkWidget *image = NULL, *frame = NULL, *evbox = NULL, *outerevbox = NULL, *timeFrame = NULL; GtkWidget *mainVBox = NULL; GdkColor black; GtkWidget *toolbar = NULL, *timeToolbar = NULL; GtkToolItem *openButton = NULL, *saveAsButton = NULL, *fontSelectButton = NULL, *timeFontSelectButton = NULL; PangoFontDescription *font_desc = NULL; struct viewport *thisport = NULL; /* init colors */ if (gdk_color_parse("#000000", &black) != TRUE) fprintf(stderr, "Could not resolve color \"black\".\n"); if (gdk_color_parse("#BBFFBB", &col_current) != TRUE) fprintf(stderr, "Could not resolve color \"col_current\".\n"); if (gdk_color_parse("#FFBBBB", &col_marked) != TRUE) fprintf(stderr, "Could not resolve color \"col_marked\".\n"); if (gdk_color_parse("#BBBBBB", &col_dim) != TRUE) fprintf(stderr, "Could not resolve color \"col_dim\".\n"); /* init our two windows */ win_preview = gtk_window_new(GTK_WINDOW_TOPLEVEL); win_beamer = gtk_window_new(GTK_WINDOW_TOPLEVEL); gtk_window_set_title(GTK_WINDOW(win_preview), "pdfpres - Preview"); gtk_window_set_title(GTK_WINDOW(win_beamer), "pdfpres - Beamer"); g_signal_connect(G_OBJECT(win_preview), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "delete_event", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_beamer), "destroy", G_CALLBACK(onQuit), NULL); g_signal_connect(G_OBJECT(win_preview), "key_press_event", G_CALLBACK(onKeyPressed), NULL); g_signal_connect(G_OBJECT(win_beamer), "key_press_event", G_CALLBACK(onKeyPressed), NULL); gtk_widget_add_events(win_beamer, GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK); g_signal_connect(G_OBJECT(win_beamer), "button_release_event", G_CALLBACK(onMouseReleased), NULL); g_signal_connect(G_OBJECT(win_beamer), "scroll_event", G_CALLBACK(onScroll), NULL); gtk_widget_add_events(win_preview, GDK_BUTTON_RELEASE_MASK | GDK_SCROLL_MASK); g_signal_connect(G_OBJECT(win_preview), "button_release_event", G_CALLBACK(onMouseReleased), NULL); g_signal_connect(G_OBJECT(win_preview), "scroll_event", G_CALLBACK(onScroll), NULL); gtk_container_set_border_width(GTK_CONTAINER(win_preview), 0); gtk_container_set_border_width(GTK_CONTAINER(win_beamer), 0); gtk_widget_modify_bg(win_beamer, GTK_STATE_NORMAL, &black); /* create buttons */ timeToolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(timeToolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(timeToolbar), 5); if (!prefs.timer_is_clock) { startButton = gtk_tool_button_new_from_stock( GTK_STOCK_MEDIA_PLAY); g_signal_connect(G_OBJECT(startButton), "clicked", G_CALLBACK(toggleTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), startButton, -1); resetButton = gtk_tool_button_new_from_stock(GTK_STOCK_MEDIA_REWIND); g_signal_connect(G_OBJECT(resetButton), "clicked", G_CALLBACK(resetTimer), NULL); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), resetButton, -1); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), gtk_separator_tool_item_new(), -1); } timeFontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(timeToolbar), timeFontSelectButton, -1); g_signal_connect(G_OBJECT(timeFontSelectButton), "clicked", G_CALLBACK(onTimerFontSelectClick), NULL); /* setting text size for time label */ timeElapsedLabel = gtk_label_new(NULL); font_desc = pango_font_description_from_string(prefs.font_timer); gtk_widget_modify_font(GTK_WIDGET(timeElapsedLabel), font_desc); pango_font_description_free(font_desc); if (prefs.timer_is_clock) { printCurrentTime(timeElapsedLabel); } else { gtk_label_set_text(GTK_LABEL(timeElapsedLabel), "00:00"); } /* Add timer label to another event box so we can set a nice border. */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), timeElapsedLabel); gtk_container_set_border_width(GTK_CONTAINER(evbox), 10); /* create timer */ timeBox = gtk_vbox_new(FALSE, 5); gtk_box_pack_start(GTK_BOX(timeBox), evbox, TRUE, TRUE, 5); gtk_box_pack_start(GTK_BOX(timeBox), timeToolbar, FALSE, FALSE, 5); if (prefs.timer_is_clock) { timeFrame = gtk_frame_new("Clock"); } else { timeFrame = gtk_frame_new("Timer"); } gtk_container_add(GTK_CONTAINER(timeFrame), timeBox); /* create note pad inside a scrolled window */ notePadBox = gtk_vbox_new(FALSE, 2); notePadScroll = gtk_scrolled_window_new(NULL, NULL); gtk_container_set_border_width(GTK_CONTAINER(notePadScroll), 5); notePadFrame = gtk_frame_new("Notes for current slide"); notePad = gtk_text_view_new(); gtk_text_view_set_editable(GTK_TEXT_VIEW(notePad), FALSE); gtk_text_view_set_cursor_visible(GTK_TEXT_VIEW(notePad), FALSE); g_signal_connect(G_OBJECT(notePad), "key_press_event", G_CALLBACK(onPadKeyPressed), NULL); /* Remarks: * * - The note pad uses word wrapping. If that's not enough, it also * uses wrapping on a per character basis. * - The note pad is placed into a GtkScrolledWindow. This window * allows vertical scrolling but no horizontal scrolling. */ gtk_text_view_set_wrap_mode(GTK_TEXT_VIEW(notePad), GTK_WRAP_WORD_CHAR); gtk_container_add(GTK_CONTAINER(notePadScroll), notePad); gtk_scrolled_window_set_shadow_type( GTK_SCROLLED_WINDOW(notePadScroll), GTK_SHADOW_IN); gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(notePadScroll), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS); gtk_box_pack_start(GTK_BOX(notePadBox), notePadScroll, TRUE, TRUE, 2); /* set note pad font and margin */ font_desc = pango_font_description_from_string(prefs.font_notes); gtk_widget_modify_font(notePad, font_desc); pango_font_description_free(font_desc); gtk_text_view_set_left_margin(GTK_TEXT_VIEW(notePad), 5); gtk_text_view_set_right_margin(GTK_TEXT_VIEW(notePad), 5); noteBuffer = gtk_text_view_get_buffer(GTK_TEXT_VIEW(notePad)); /* We detect changes of the notes by catching the "changed" signal. * As this signal is also emitted when we change the buffer * programmatically, we first have a look if there was a * "begin_user_action" signal. If so, the user has changed the * buffer. */ g_signal_connect(G_OBJECT(noteBuffer), "changed", G_CALLBACK(onEditing), NULL); g_signal_connect(G_OBJECT(noteBuffer), "begin_user_action", G_CALLBACK(onBeginUserAction), NULL); g_signal_connect(G_OBJECT(noteBuffer), "end_user_action", G_CALLBACK(onEndUserAction), NULL); /* create toolbar */ toolbar = gtk_toolbar_new(); gtk_toolbar_set_style(GTK_TOOLBAR(toolbar), GTK_TOOLBAR_ICONS); gtk_container_set_border_width(GTK_CONTAINER(toolbar), 5); openButton = gtk_tool_button_new_from_stock(GTK_STOCK_OPEN); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), openButton, -1); g_signal_connect(G_OBJECT(openButton), "clicked", G_CALLBACK(onOpenClicked), NULL); /* TODO: Tooltips?! */ saveButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveButton, -1); gtk_widget_set_sensitive(GTK_WIDGET(saveButton), FALSE); g_signal_connect(G_OBJECT(saveButton), "clicked", G_CALLBACK(onSaveClicked), NULL); saveAsButton = gtk_tool_button_new_from_stock(GTK_STOCK_SAVE_AS); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), saveAsButton, -1); g_signal_connect(G_OBJECT(saveAsButton), "clicked", G_CALLBACK(onSaveAsClicked), NULL); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), gtk_separator_tool_item_new(), -1); editButton = gtk_toggle_tool_button_new_from_stock(GTK_STOCK_EDIT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), editButton, -1); g_signal_connect(G_OBJECT(editButton), "toggled", G_CALLBACK(onEditToggled), NULL); fontSelectButton = gtk_tool_button_new_from_stock(GTK_STOCK_SELECT_FONT); gtk_toolbar_insert(GTK_TOOLBAR(toolbar), fontSelectButton, -1); g_signal_connect(G_OBJECT(fontSelectButton), "clicked", G_CALLBACK(onFontSelectClick), NULL); gtk_box_pack_start(GTK_BOX(notePadBox), toolbar, FALSE, FALSE, 2); gtk_container_add(GTK_CONTAINER(notePadFrame), notePadBox); /* init containers for "preview" */ table = gtk_table_new(numframes, numframes + 1, TRUE); gtk_table_set_col_spacings(GTK_TABLE(table), 5); gtk_container_set_border_width(GTK_CONTAINER(table), 10); /* dynamically create all the frames */ for (i = 0; i < numframes; i++) { /* calc the offset for this frame */ transIndex = i - (int)((double)numframes / 2.0); /* create the widget - note that it is important not to * set the title to NULL. this would cause a lot more * redraws on startup because the frame will get re- * allocated when the title changes. */ frame = gtk_frame_new(""); /* create a new drawing area - the pdf will be rendered in * there */ image = gtk_image_new(); /* add widgets to their parents. the image is placed in an * eventbox, the box's size_allocate signal will be handled. so, * we know the exact width/height we can render into. (placing * the image into the frame would create the need of knowing the * frame's border size...) */ evbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(evbox), image); gtk_container_add(GTK_CONTAINER(frame), evbox); /* every frame will be placed in another eventbox so we can set a * background color */ outerevbox = gtk_event_box_new(); gtk_container_add(GTK_CONTAINER(outerevbox), frame); if (i == 0) { gtk_table_attach_defaults(GTK_TABLE(table), notePadFrame, 0, 1, 0, numframes - 1); gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, 0, 1, numframes - 1, numframes); } else { if (i == numframes - 1) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, numframes, numframes + 1, 0, 1); gtk_table_attach_defaults(GTK_TABLE(table), timeFrame, numframes, numframes + 1, numframes - 1, numframes); } else { if (i == (int)(numframes / 2)) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, i, i + 2, 0, numframes); } else { if (i < (int)(numframes / 2)) { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, i, i + 1, numframes - i - 1, numframes - i); } else { gtk_table_attach_defaults(GTK_TABLE(table), outerevbox, i + 1, i + 2, numframes - i - 1, numframes - i); } } } } /* make the eventbox "transparent" */ gtk_event_box_set_visible_window(GTK_EVENT_BOX(evbox), FALSE); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = transIndex; thisport->image = image; thisport->frame = frame; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = FALSE; ports = g_list_append(ports, thisport); /* resize callback */ g_signal_connect(G_OBJECT(evbox), "size_allocate", G_CALLBACK(onResize), thisport); g_signal_connect(G_OBJECT(evbox), "expose_event", G_CALLBACK(onExpose), thisport); } /* Add main content and a status bar to preview window. * * Note: It's important to use gtk_box_pack_* to add the statusbar * because gtk_container_add will pick unappropriate defaults. */ mainVBox = gtk_vbox_new(FALSE, 5); gtk_container_add(GTK_CONTAINER(mainVBox), table); mainStatusbar = gtk_statusbar_new(); gtk_box_pack_end(GTK_BOX(mainVBox), mainStatusbar, FALSE, FALSE, 0); setStatusText_strdup("Ready."); gtk_container_add(GTK_CONTAINER(win_preview), mainVBox); /* in order to set the initially highlighted frame */ refreshFrames(); /* add a rendering area to the beamer window */ image = gtk_image_new(); gtk_container_add(GTK_CONTAINER(win_beamer), image); /* save info of this rendering port */ thisport = (struct viewport *)malloc(sizeof(struct viewport)); g_assert(thisport); thisport->offset = 0; thisport->image = image; thisport->frame = NULL; thisport->pixbuf = NULL; thisport->width = -1; thisport->height = -1; thisport->isBeamer = TRUE; ports = g_list_append(ports, thisport); /* connect the on-resize-callback directly to the window */ g_signal_connect(G_OBJECT(win_beamer), "size_allocate", G_CALLBACK(onResize), thisport); g_signal_connect(G_OBJECT(win_beamer), "expose_event", G_CALLBACK(onExpose), thisport); /* load notes if requested */ if (notefile) { showNotesFromFile(notefile); } /* Set default sizes for both windows. (Note: If the widgets don't * fit into that space, the windows will be larger. Also, they are * allowed to get shrinked by the user.) */ gtk_window_set_default_size(GTK_WINDOW(win_preview), 640, 480); gtk_window_set_default_size(GTK_WINDOW(win_beamer), 320, 240); /* show the windows */ gtk_widget_show_all(win_preview); gtk_widget_show_all(win_beamer); /* now, as the real gdk window exists, hide mouse cursor in the * beamer window */ gdk_window_set_cursor(gtk_widget_get_window(GTK_WIDGET(win_beamer)), gdk_cursor_new(GDK_BLANK_CURSOR)); /* Show a clock or a timer? */ if (prefs.timer_is_clock) { g_timeout_add(500, (GSourceFunc)printCurrentTime, (gpointer)timeElapsedLabel); } else { g_timeout_add(500, (GSourceFunc)printTimeElapsed, (gpointer)timeElapsedLabel); } }
static int readerTest(int ctn) { int8_t res; uint8_t rsp[256+2]; uint8_t sad, dad; uint16_t lenc, lenr; uint8_t apdu_reset_icc[]={0x20, 0x11, 0x01, 0x01, 0x00}; #ifdef VERBOUS printCurrentTime(stdout); fprintf(stdout, "Thread %d: Started\n", ctn); #endif res=CT_init(ctn, ctn); if (res!=CT_API_RV_OK) { fprintf(stderr, "===== CTAPI(%d): Error on CT_init (%d)\n", ctn, res); return -1; } lenc=sizeof(apdu_reset_icc); lenr=sizeof(rsp); sad=2; dad=CT_API_AD_CT; res=CT_data(ctn, &dad, &sad, lenc, apdu_reset_icc, &lenr, rsp); if (res!=CT_API_RV_OK) { fprintf(stderr, "===== CTAPI::RESET_ICC(%d): Error on CT_data (%d)\n", ctn, res); CT_close(ctn); return -1; } if (lenr<2) { fprintf(stderr, "===== CTAPI::RESET_ICC(%d): Too few bytes returned (%d)\n", ctn, lenr); CT_close(ctn); return -1; } if (rsp[lenr-2]==0x90) { int loop; #ifdef VERBOUS printCurrentTime(stdout); fprintf(stdout, "Thread %d: Got a card\n", ctn); #endif for (loop=0; loop<NUM_LOOPS; loop++) { long int r; uint8_t apdu_select_mf[]={0x00, 0xa4, 0x00, 0x00, 0x02, 0x3f, 0x00, 0x00}; lenc=sizeof(apdu_select_mf); lenr=sizeof(rsp); sad=2; dad=CT_API_AD_CT; #ifdef VERBOUS printCurrentTime(stdout); fprintf(stdout, "Thread %d: -> Selecting MF\n", ctn); #endif res=CT_data(ctn, &dad, &sad, lenc, apdu_select_mf, &lenr, rsp); #ifdef VERBOUS printCurrentTime(stdout); fprintf(stdout, "Thread %d: <- Returned from selecting MF\n", ctn); #endif if (res!=CT_API_RV_OK) { fprintf(stderr, "===== CTAPI::SELECT_MF(%d): Error on CT_data (%d)\n", ctn, res); CT_close(ctn); return -1; } if (lenr<2) { fprintf(stderr, "===== CTAPI::SELECT_MF(%d): Too few bytes returned (%d)\n", ctn, lenr); CT_close(ctn); return -1; } if (rsp[lenr-2]==0x90) { #ifdef VERBOUS printCurrentTime(stdout); fprintf(stdout, "Thread %d: MF selected.\n", ctn); #endif } else { fprintf(stderr, "===== CTAPI::SELECT_MF(%d): Command error (%02x %02x)\n", ctn, rsp[lenr-2], rsp[lenr-1]); CT_close(ctn); return -1; } r=(random()% 200); #ifdef VERBOUS usleep(r); #endif } } else { fprintf(stderr, "===== CTAPI::RESET_ICC(%d): No card (%02x %02x)\n", ctn, rsp[lenr-2], rsp[lenr-1]); CT_close(ctn); return -1; } sleep(2); res=CT_close(ctn); if (res!=CT_API_RV_OK) { fprintf(stderr, "===== CTAPI(ctn): Error on CT_close (%d)\n", res); return -1; } #ifdef VERBOUS fprintf(stdout, "Thread %d: Stopped\n", ctn); #endif return 0; }
int putFile(int connectionId, char *filename) { //get the destination struct host *destination = getHostByID(connectionList, connectionId); if (destination == NULL) { printf("Count't find connection id to send file.\n"); return -1; } //get the filename removing the directory names int filenamePartLength; char **filenameParts = splitString(strdup(filename), '/', &filenamePartLength); char *justFilename = filenameParts[filenamePartLength - 1]; //open file FILE *fp = fopen(filename, "rb"); //rb is for opening binary files if (fp == NULL) { printf("Filename: %s, %s\n", filename, strerror(errno)); return -2; } printf("Starting to send file: %s at %s.\n", justFilename, printCurrentTime()); //Read data for first packet char buff[PACKET_SIZE]; int data_read = 0; int bytes_read = fread(buff, 1, PACKET_SIZE, fp); if (bytes_read < PACKET_SIZE) buff[bytes_read] = 0; data_read += bytes_read; //printf("Bytes read %d \n", bytes_read); if (bytes_read <= 0 && ferror(fp)) { printf("Error reading file: %s\n", filename); fclose(fp); return -3; } struct packet *pckt = packetBuilder(put, justFilename, bytes_read, ""); char *packetString = packetDecoder(pckt); // printf("Packet String: %s\n", packetString); // printPacket(pckt); int header_bytes_sent = send(destination->sockfd, packetString, strlen(packetString), 0); //send the data separately as is it is not text int data_bytes_sent = send(destination->sockfd, buff, bytes_read, 0); //printf("Number of bytes sent: %d\n", header_bytes_sent + data_bytes_sent); free(pckt); pckt = NULL; //check if there is more data if so send them in packets while (true) { if (bytes_read < PACKET_SIZE) { if (feof(fp)) //reached EOF no need to print anything just beak if (ferror(fp)) printf("Error reading file: %s\n", filename); break; } bytes_read = fread(buff, 1, PACKET_SIZE, fp); if (bytes_read < PACKET_SIZE) buff[bytes_read] = 0; data_read += bytes_read; pckt = packetBuilder(put, justFilename, bytes_read, ""); packetString = packetDecoder(pckt); //printf("Packet String: %s\n", packetString); // printPacket(pckt); header_bytes_sent = send(destination->sockfd, packetString, strlen(packetString), 0); //send the data separately as it is not text data_bytes_sent = send(destination->sockfd, buff, bytes_read, 0); //printf("Number of bytes sent: %d\n", data_bytes_sent); free(pckt); pckt = NULL; } printf("Completed sending file: %s at %s.\n", justFilename, printCurrentTime()); //send a ok message to indicate completion. pckt = packetBuilder(ok, justFilename, 0, ""); packetString = packetDecoder(pckt); // printf("OK Packet String: %s\n", packetString); // printPacket(pckt); int bytes_sent = send(destination->sockfd, packetString, strlen(packetString), 0); //printf("ok packet Number of bytes sent: %d\n", bytes_sent); return 0; }