decltype(auto) matrix_transpose( InputRange const& input, OutputRange& output, int row_size, int col_size, boost::compute::command_queue& queue) { NEU_ASSERT(row_size*col_size == range::distance(input)); static auto transpose_kernel = neu::make_kernel(neu::layer::impl::matrix_transpose_kernel_source, "matrix_transpose", queue.get_context()); transpose_kernel.set_args( range::get_buffer(input), static_cast<cl_int>(range::get_begin_index(input)), range::get_buffer(output), static_cast<cl_int>(range::get_begin_index(output)), static_cast<cl_int>(row_size), static_cast<cl_int>(col_size)); std::size_t global[2] = { static_cast<std::size_t>(((col_size-1)/32+1)*32), static_cast<std::size_t>(((row_size-1)/32+1)*32) }; std::size_t local[2] = { static_cast<std::size_t>(32), static_cast<std::size_t>(32) }; queue.enqueue_nd_range_kernel(transpose_kernel, 2, nullptr, global, local); }
int32 ntabca_(int32 *father_frame, int32 dum1, int32 dum2, int32 dum3) #endif { char *tab,*arg_pere; int32 num,max,nbr; int32 i; /*=-=-=-=-= Cette partie est strictement UNIX =-=-=-=-=-=-=-=-=-=-==-=-=-=-=*/ #ifndef sgi father_stack = *stp; res = recup_arg_();/* La fonction qui copie les argument dans le tableau */ /* "list_arg_moi", et position "nb_arg_moi" =-=-=-=-=*/ /*=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=*/ if (res == 0) { printf(" %%VARARG-ERR : FATAL ERROR \n"); exit (-1); } else if (res == 2) return (0); #else set_args((uint32 *) father_frame, (uint32 *) comargs__); #endif if (nb_arg_moi < 4 || nb_arg_moi > 5) { return(PAQUOT); /* Erreur de Syntaxe */ } num = *(list_arg_moi[1]); /* Numero d'argument pere */ if ((num > nb_arg_pere) || (num <= 0)) { return(PAQUOT); /* Erreur */ } arg_pere = (char *)list_arg_pere[num-1]; max = *(list_arg_moi[2]); if (nb_arg_moi == 5) {/* Syntaxe NTABCA(LLL999,NUM,MAX,TAB,VALARG) */ /*=-= On copie dans VAlARG, le 1er mot de l'arg_pere =-=-=*/ COPY_MOT(arg_pere, list_arg_moi[4]); } if (*(arg_pere++) != QUOT) { return(PAQUOT); /* Erreur il faut que la chaine commance par QUOT */ } for (nbr=0; *(arg_pere) != QUOT && nbr<MAX_CAR; nbr++, arg_pere++) { if (nbr < max) { *(tab++) = *(arg_pere); } } if (*(arg_pere) != QUOT) { return(PAQUOT); /* Erreur il faut que la chaine termine par QUOT */ } for (i=nbr; i < max; i++) { *(tab++) = ' '; } return(nbr); }
void tabarg_(uint32 *father_frame, int32 dum1, int32 dum2, int32 dum3) { adresse tab_pere; int32 *num; int32 *nbr; int32 *tab; int32 i, max; set_args(father_frame, (uint32 *) comargs__); num = (int *)list_arg_moi[1]; nbr = (int *)list_arg_moi[2]; tab = (int *)list_arg_moi[3]; if (*num > nb_arg_pere || *num <= 0) return; max = *nbr; tab_pere = list_arg_pere[*num-1]; for (i=0; i<max; i++) { COPY_MOT(tab_pere, tab); tab_pere++; tab++; } }
void rretrg_(uint32 *father_frame, int32 dum1, int32 dum2, int32 dum3) { int32 num, nbr; adresse tab, tab_pere; int32 i; set_args(father_frame, (uint32 *) comargs__); if (nb_arg_moi > 4 || nb_arg_moi < 3) return; num = *(list_arg_moi[1]); if (num<=0 || num>nb_arg_pere) return; if (nb_arg_moi ==3) { COPY_MOT(list_arg_moi[2], list_arg_pere[num-1]) } else { nbr = *(list_arg_moi[2]); tab = list_arg_moi[3]; tab_pere = list_arg_pere[num-1]; for (i=0; i<nbr; i++) { COPY_MOT(tab,tab_pere) tab_pere++; tab++; } } }
int32 nartab_(uint32 *father_frame, int32 dum1, int32 dum2, int32 dum3) { adresse *pere; int32 *imax; int32 *tab; int32 i, max; set_args(father_frame, (uint32 *) comargs__); imax = (int *)list_arg_moi[1]; tab = (int *)list_arg_moi[2]; max = *imax; if (max > nb_arg_pere) max = nb_arg_pere; pere = list_arg_pere; for (i=0; i<max; i++) { COPY_MOT(*pere, tab) pere++; tab++; } return(nb_arg_pere); }
void mips1::init(int ac, char *av[]) { extern char* appfilename; initCache(); ac_init_opt( ac, av); ac_init_app( ac, av); APP_MEM->load(appfilename); set_args(ac_argc, ac_argv); #ifdef AC_VERIFY set_queue(av[0]); #endif ac_pc = ac_start_addr; ISA._behavior_begin(); cerr << "ArchC: -------------------- Starting Simulation --------------------" << endl; InitStat(); hazard_count = 0; memset(hazard_count_by_type, 0, sizeof(hazard_count_by_type)); signal(SIGINT, sigint_handler); signal(SIGTERM, sigint_handler); signal(SIGSEGV, sigsegv_handler); signal(SIGUSR1, sigusr1_handler); #ifdef USE_GDB signal(SIGUSR2, sigusr2_handler); #endif #ifndef AC_COMPSIM set_running(); #else void Execute(int argc, char *argv[]); Execute(argc, argv); #endif }
int main() { // create a compute context and command queue auto ctx = boost::compute::system::default_context(); auto queue = boost::compute::system::default_queue(); // create program and kernels std::ostringstream source; get_file_contents(source, "svd3.cl"); auto program = boost::compute::program::build_with_source(source.str(), ctx); auto svdArrayTestKernel = program.create_kernel("svdArrayTest"); EigenMatN A_host = EigenMatN::Identity(); boost::compute::vector<cl_float> A_dev(A_host.data(), A_host.data() + N_*N_, queue); boost::compute::vector<cl_float> U_dev(N_*N_), S_dev(N_*N_), V_dev(N_*N_); svdArrayTestKernel.set_args(A_dev, U_dev, S_dev, V_dev); queue.enqueue_1d_range_kernel(svdArrayTestKernel, 0, 1, 0); EigenMatN U_host,S_host,V_host; boost::compute::copy(U_dev.begin(), U_dev.end(), U_host.data()); boost::compute::copy(S_dev.begin(), S_dev.end(), S_host.data()); boost::compute::copy(V_dev.begin(), V_dev.end(), V_host.data()); std::cout << A_host << std::endl; std::cout << U_host << std::endl; std::cout << S_host << std::endl; std::cout << V_host << std::endl; return 0; }
void mips1::init() { set_args(ac_argc, ac_argv); #ifdef AC_VERIFY set_queue(av[0]); #endif ISA._behavior_begin(); cerr << "ArchC: -------------------- Starting Simulation --------------------" << endl; InitStat(); signal(SIGINT, sigint_handler); signal(SIGTERM, sigint_handler); signal(SIGSEGV, sigsegv_handler); signal(SIGUSR1, sigusr1_handler); #ifdef USE_GDB signal(SIGUSR2, sigusr2_handler); #endif #ifndef AC_COMPSIM set_running(); #else ac_pc = 0; void Execute(int argc, char *argv[]); Execute(argc, argv); #endif }
void start_quip_with_menu(int argc, char **argv, Menu *initial_menu_p ) { Query_Stack *qsp; assert( initial_menu_p != NULL ); set_progname(argv[0]); first_menu = initial_menu_p; //debug |= CTX_DEBUG_MASK; //debug |= GETBUF_DEBUG_MASK; qsp=init_first_query_stack(); // reads stdin? init_builtins(); init_variables(SINGLE_QSP_ARG); // specify dynamic variables declare_functions(SINGLE_QSP_ARG); //PUSH_MENU(quip); PUSH_MENU_PTR(initial_menu_p); set_args(QSP_ARG argc,argv); rcfile(qsp,argv[0]); // If we have commands to create a widget in the startup file, // we get an error, so don't call exec_quip until after the appDelegate // has started... } // end start_quip_with_menu
THREAD_RETURN YASSL_API server_test(void* args) { #ifdef _WIN32 WSADATA wsd; WSAStartup(0x0002, &wsd); #endif SOCKET_T sockfd = 0; SOCKET_T clientfd = 0; int argc = 0; char** argv = 0; set_args(argc, argv, *static_cast<func_args*>(args)); tcp_accept(sockfd, clientfd, *static_cast<func_args*>(args)); tcp_close(sockfd); SSL_METHOD* method = TLSv1_server_method(); SSL_CTX* ctx = SSL_CTX_new(method); //SSL_CTX_set_cipher_list(ctx, "RC4-SHA:RC4-MD5"); SSL_CTX_set_verify(ctx, SSL_VERIFY_PEER, 0); set_serverCerts(ctx); DH* dh = set_tmpDH(ctx); SSL* ssl = SSL_new(ctx); SSL_set_fd(ssl, clientfd); #ifdef NON_BLOCKING NonBlockingSSL_Accept(ssl, ctx, clientfd); #else if (SSL_accept(ssl) != SSL_SUCCESS) ServerError(ctx, ssl, clientfd, "SSL_accept failed"); #endif showPeer(ssl); printf("Using Cipher Suite: %s\n", SSL_get_cipher(ssl)); char command[1024]; int input = SSL_read(ssl, command, sizeof(command)); if (input > 0) { command[input] = 0; printf("First client command: %s\n", command); } char msg[] = "I hear you, fa shizzle!"; if (SSL_write(ssl, msg, sizeof(msg)) != sizeof(msg)) ServerError(ctx, ssl, clientfd, "SSL_write failed"); DH_free(dh); SSL_CTX_free(ctx); SSL_shutdown(ssl); SSL_free(ssl); tcp_close(clientfd); ((func_args*)args)->return_code = 0; return 0; }
void parse_options() { if(ttm.arg.ap.set) ttm.arg.ap.num = set_args(ap_buf, ttm.arg.ap.data, MAX_AP_NUM); if(ttm.arg.fb.set) ttm.arg.fb.num = set_args(fb_buf, ttm.arg.fb.data, MAX_PNL_NUM); if(ttm.arg.evt.set) ttm.arg.evt.num = set_args(evt_buf, ttm.arg.evt.data, MAX_PNL_NUM); if(ttm.arg.pnl_evt.set) ttm.arg.pnl_evt.num = set_args(pnl_evt_buf, ttm.arg.pnl_evt.data, MAX_PNL_NUM); if(ttm.arg.bind.set) { ttm.arg.bind.num = set_args(bind_buf, ttm.arg.bind.data, MAX_PNL_NUM + MAX_AP_NUM); set_binds(); } }
/* Main procedure for fortran programs. All we do is set up the environment for the Fortran program. */ int main (int argc, char *argv[]) { /* Set up the runtime environment. */ set_args (argc, argv); /* Call the Fortran main program. Internally this is a function called MAIN__ */ MAIN__ (); /* Bye-bye! */ return 0; }
int main(int ac, char **av) { t_args args; t_list *path; args = (t_args){0, 0, 0, 0, 0, 0, 0, 0}; path = NULL; if (ac > 1) set_args(&path, &args, av, ac - 1); if (path == NULL) path = ft_lstnew(".", 1); ft_ls(path, args, path->next != NULL ? 1 : 0); return (0); }
void sinsp_chisel::on_init() { // // Done with the arguments, call init() // lua_getglobal(m_ls, "on_init"); if(lua_pcall(m_ls, 0, 1, 0) != 0) { // // No on_init. // That's ok. Just return. // return; } if(m_new_chisel_to_exec == "") { if(!lua_isboolean(m_ls, -1)) { throw sinsp_exception(m_filename + " chisel error: wrong init() return value."); } if(!lua_toboolean(m_ls, -1)) { throw sinsp_exception("init() for chisel " + m_filename + " failed."); } } lua_pop(m_ls, 1); // // If the chisel called chisel.exec(), free this chisel and load the new one // if(m_new_chisel_to_exec != "") { free_lua_chisel(); load(m_new_chisel_to_exec); m_new_chisel_to_exec = ""; vector<string> args = m_argvals; m_argvals.clear(); set_args(&args); on_init(); } }
int32 nargum_(uint32 *father_frame, int32 dum1, int32 dum2, int32 dum3) { adresse *pere, *moi; int32 i, max; set_args(father_frame, (uint32 *) comargs__); max = num_father_args<num_son_args ? num_father_args : num_son_args - 1; pere = list_arg_pere; moi = &list_arg_moi[1]; for (i=0; i<max; i++) { COPY_MOT(*pere, *moi) pere++; moi++; } return(nb_arg_pere); }
double function() { std::string name = cur_val.string_value; std::string args; if (set_args(args)) { double result; Token_value tmp; switch (tmp = get_token()) { case ASSIGN: result = def_func(name, args); curr_tok = PRINT; break; default: result = call_func(name, args); curr_tok = tmp; break; } return result; } else return error(""); }
uint32 rretvr_(uint32 *father_frame, int32 dum1, int32 dum2, int32 dum3) { int32 nbr, nini; adresse tab, *pere; int32 i, max; extern uint32 risc_return_ (uint32 *); set_args(father_frame, (uint32 *) comargs__); ctrace_[0]--; if (nb_arg_moi > 4 || nb_arg_moi < 3) return 0; if (nb_arg_moi==3) { risc_return_(list_arg_moi[2]); return(*list_arg_moi[2]); } else { nbr = *list_arg_moi[1]; nini = *list_arg_moi[2] - 1; if (nini<0) return 0; tab = list_arg_moi[3]; pere = &list_arg_pere[nini]; max = nb_arg_pere - nini; if (max > nbr) max = nbr; for (i=0; i<max; i++) { COPY_MOT(tab,*pere) pere++; tab++; } } return 0; }
/** Collect all information about a process * * The psinfo variable is so that /proc/<pid>/psinfo only needs to be read * once. */ struct psi_process * psi_arch_process(const pid_t pid) { struct psi_process *proci; struct procentry64 procent; int r; r = getprocent(&procent, pid); if (r < 0) return NULL; proci = psi_calloc(sizeof(struct psi_process)); if (proci == NULL) return NULL; if (set_bulk(proci, &procent) < 0) return psi_free_process(proci); if (set_args(proci, &procent) < 0) return psi_free_process(proci); if (set_env(proci, &procent) < 0) return psi_free_process(proci); if (set_cwd(proci, &procent) < 0) return psi_free_process(proci); return proci; }
THREAD_RETURN YASSL_API echoserver_test(void* args) { #ifdef _WIN32 WSADATA wsd; WSAStartup(0x0002, &wsd); #endif SOCKET_T sockfd = 0; int argc = 0; char** argv = 0; set_args(argc, argv, *static_cast<func_args*>(args)); #ifdef ECHO_OUT FILE* fout = stdout; if (argc >= 2) fout = fopen(argv[1], "w"); if (!fout) err_sys("can't open output file"); #endif tcp_listen(sockfd); SSL_METHOD* method = SSLv23_server_method(); SSL_CTX* ctx = SSL_CTX_new(method); set_serverCerts(ctx); DH* dh = set_tmpDH(ctx); bool shutdown(false); #if defined(_POSIX_THREADS) && defined(NO_MAIN_DRIVER) // signal ready to tcp_accept func_args& server_args = *((func_args*)args); tcp_ready& ready = *server_args.signal_; pthread_mutex_lock(&ready.mutex_); ready.ready_ = true; pthread_cond_signal(&ready.cond_); pthread_mutex_unlock(&ready.mutex_); #endif while (!shutdown) { SOCKADDR_IN_T client; socklen_t client_len = sizeof(client); SOCKET_T clientfd = accept(sockfd, (sockaddr*)&client, (ACCEPT_THIRD_T)&client_len); if (clientfd == (SOCKET_T) -1) { SSL_CTX_free(ctx); tcp_close(sockfd); err_sys("tcp accept failed"); } SSL* ssl = SSL_new(ctx); SSL_set_fd(ssl, clientfd); if (SSL_accept(ssl) != SSL_SUCCESS) { printf("SSL_accept failed\n"); SSL_free(ssl); tcp_close(clientfd); continue; } char command[1024]; int echoSz(0); while ( (echoSz = SSL_read(ssl, command, sizeof(command))) > 0) { if ( strncmp(command, "quit", 4) == 0) { printf("client sent quit command: shutting down!\n"); shutdown = true; break; } else if ( strncmp(command, "GET", 3) == 0) { char type[] = "HTTP/1.0 200 ok\r\nContent-type:" " text/html\r\n\r\n"; char header[] = "<html><body BGCOLOR=\"#ffffff\">\n<pre>\n"; char body[] = "greetings from yaSSL\n"; char footer[] = "</body></html>\r\n\r\n"; strncpy(command, type, sizeof(type)); echoSz = sizeof(type) - 1; strncpy(&command[echoSz], header, sizeof(header)); echoSz += sizeof(header) - 1; strncpy(&command[echoSz], body, sizeof(body)); echoSz += sizeof(body) - 1; strncpy(&command[echoSz], footer, sizeof(footer)); echoSz += sizeof(footer); if (SSL_write(ssl, command, echoSz) != echoSz) EchoError(ctx, ssl, sockfd, clientfd, "SSL_write failed"); break; } command[echoSz] = 0; #ifdef ECHO_OUT fputs(command, fout); #endif if (SSL_write(ssl, command, echoSz) != echoSz) EchoError(ctx, ssl, sockfd, clientfd, "SSL_write failed"); } SSL_shutdown(ssl); SSL_free(ssl); tcp_close(clientfd); } tcp_close(sockfd); DH_free(dh); SSL_CTX_free(ctx); ((func_args*)args)->return_code = 0; return 0; }
void processCL_sse2(const VSFrameRef * src, const VSFrameRef * scp, VSFrameRef * dst, VSFrameRef ** pad, const int field_n, const EEDI3CLData * d, const VSAPI * vsapi) { for (int plane = 0; plane < d->vi.format->numPlanes; plane++) { if (d->process[plane]) { copyPad<T>(src, pad[plane], plane, 1 - field_n, d->dh, vsapi); const int srcWidth = vsapi->getFrameWidth(pad[plane], 0); const int dstWidth = vsapi->getFrameWidth(dst, plane); const int srcHeight = vsapi->getFrameHeight(pad[plane], 0); const int dstHeight = vsapi->getFrameHeight(dst, plane); const int srcStride = vsapi->getStride(pad[plane], 0) / sizeof(T); const int dstStride = vsapi->getStride(dst, plane) / sizeof(T); const T * _srcp = reinterpret_cast<const T *>(vsapi->getReadPtr(pad[plane], 0)); T * VS_RESTRICT _dstp = reinterpret_cast<T *>(vsapi->getWritePtr(dst, plane)); const auto threadId = std::this_thread::get_id(); auto queue = d->queue.at(threadId); auto calculateConnectionCosts = d->calculateConnectionCosts.at(threadId); auto srcImage = d->src.at(threadId); auto _ccosts = d->ccosts.at(threadId); float * pcosts = d->pcosts.at(threadId) + d->mdisVector; int * _pbackt = d->pbackt.at(threadId) + d->mdisVector; int * fpath = d->fpath.at(threadId); int * _dmap = d->dmap.at(threadId); float * tline = d->tline.at(threadId); const size_t globalWorkSize[] = { static_cast<size_t>((dstWidth + 15) & -16), static_cast<size_t>(d->vectorSize) }; constexpr size_t localWorkSize[] = { 16, 4 }; const int bufferSize = dstWidth * d->tpitchVector * sizeof(cl_float); vs_bitblt(_dstp + dstStride * (1 - field_n), vsapi->getStride(dst, plane) * 2, _srcp + srcStride * (4 + 1 - field_n) + 12, vsapi->getStride(pad[plane], 0) * 2, dstWidth * sizeof(T), dstHeight / 2); queue.enqueue_write_image(srcImage, compute::dim(0, 0), compute::dim(srcWidth, srcHeight), _srcp, vsapi->getStride(pad[plane], 0)); for (int y = 4 + field_n; y < srcHeight - 4; y += 2 * d->vectorSize) { const int off = (y - 4 - field_n) >> 1; calculateConnectionCosts.set_args(srcImage, _ccosts, dstWidth, srcHeight - 4, y); queue.enqueue_nd_range_kernel(calculateConnectionCosts, 2, nullptr, globalWorkSize, localWorkSize); float * ccosts = reinterpret_cast<float *>(queue.enqueue_map_buffer(_ccosts, CL_MAP_READ, 0, bufferSize)) + d->mdisVector; // calculate path costs Vec4f().load(ccosts).store_a(pcosts); for (int x = 1; x < dstWidth; x++) { const float * tT = ccosts + d->tpitchVector * x; const float * ppT = pcosts + d->tpitchVector * (x - 1); float * pT = pcosts + d->tpitchVector * x; int * piT = _pbackt + d->tpitchVector * (x - 1); const int umax = std::min({ x, dstWidth - 1 - x, d->mdis }); const int umax2 = std::min({ x - 1, dstWidth - x, d->mdis }); for (int u = -umax; u <= umax; u++) { Vec4i idx = zero_128b(); Vec4f bval = FLT_MAX; for (int v = std::max(-umax2, u - 1); v <= std::min(umax2, u + 1); v++) { const Vec4f z = Vec4f().load_a(ppT + v * d->vectorSize) + d->gamma * std::abs(u - v); const Vec4f ccost = min(z, FLT_MAX * 0.9f); idx = select(Vec4ib(ccost < bval), v, idx); bval = min(ccost, bval); } const Vec4f z = bval + Vec4f().load(tT + u * d->vectorSize); min(z, FLT_MAX * 0.9f).store_a(pT + u * d->vectorSize); idx.stream(piT + u * d->vectorSize); } } for (int vs = 0; vs < d->vectorSize; vs++) { const int realY = 4 + field_n + 2 * (off + vs); if (realY >= srcHeight - 4) break; const T * srcp = _srcp + srcStride * realY + 12; T * dstp = _dstp + dstStride * (field_n + 2 * (off + vs)); int * dmap = _dmap + dstWidth * (off + vs); const T * src3p = srcp - srcStride * 3; const T * src1p = srcp - srcStride; const T * src1n = srcp + srcStride; const T * src3n = srcp + srcStride * 3; const int * pbackt = _pbackt + vs; // backtrack fpath[dstWidth - 1] = 0; for (int x = dstWidth - 2; x >= 0; x--) fpath[x] = pbackt[(d->tpitch * x + fpath[x + 1]) * d->vectorSize]; interpolate<T>(src3p, src1p, src1n, src3n, fpath, dmap, dstp, dstWidth, d->ucubic, d->peak); } queue.enqueue_unmap_buffer(_ccosts, ccosts - d->mdisVector); } if (d->vcheck) { const T * srcp = _srcp + srcStride * (4 + field_n) + 12; const T * scpp = nullptr; if (d->sclip) scpp = reinterpret_cast<const T *>(vsapi->getReadPtr(scp, plane)) + dstStride * field_n; T * dstp = _dstp + dstStride * field_n;; vCheck<T>(srcp, scpp, dstp, _dmap, tline, field_n, dstWidth, srcHeight, srcStride, dstStride, d->vcheck, d->vthresh2, d->rcpVthresh0, d->rcpVthresh1, d->rcpVthresh2, d->peak); } } }
int main(int arg, char *argv[]) { WSMMessage rxmsg; WSMIndication rxpkt; //int i, attempts = 10, drops = 0, result; int ret = 0; struct arguments arg1; rxmsg.wsmIndication = &rxpkt; /* check for the user input arguments, if it is less than 4 print the usage message */ if (arg < 4) { printf("usage: localrx [user req type<1-auto> <2-unconditional> <3-none>] [imm access] [extended access] [channel <optional>] [PROVIDER MAC <optional>]\n"); return 0; } registerLinkConfirm(confirmBeforeJoin); /* Registering the callback function */ pid = getpid(); memset(&entry, 0, sizeof(WMEApplicationRequest)); entry.psid = 10; if ((atoi(argv[1]) > USER_REQ_SCH_ACCESS_NONE) || (atoi(argv[1]) < USER_REQ_SCH_ACCESS_AUTO)) { printf("User request type invalid: setting default to auto\n"); entry.userreqtype = USER_REQ_SCH_ACCESS_AUTO; } else { entry.userreqtype = atoi(argv[1]); } if (entry.userreqtype == USER_REQ_SCH_ACCESS_AUTO_UNCONDITIONAL) { if (arg < 5) { printf("channel needed for unconditional access\n"); return 0; } else { entry.channel = atoi(argv[4]); } } entry.schaccess = atoi(argv[2]); entry.schextaccess = atoi(argv[3]); if (arg > 5) { strncpy(arg1.macaddr, argv[4], 17); set_args(entry.macaddr, &arg1, ADDR_MAC); } /* Function invokeWAVEDevice(int type, int blockflag)/invokeWAVEDriver(int blockflag) instructs the libwave * to open a connection to a wave device either on the local machine or on a remote machine. * Invoke the wave device before issuing any request to the wave device */ printf("Invoking WAVE driver \n"); if (invokeWAVEDevice(WAVEDEVICE_LOCAL, 0) < 0) { printf("Open Failed. Quitting\n"); exit(-1); } /* Registering the user to receive the data from the TX application */ printf("Registering User %d\n", entry.psid); if (registerUser(pid, &entry) < 0) { printf("Register User Failed \n"); printf("Removing user if already present %d\n", !removeUser(pid, &entry)); printf("USER Registered %d with PSID =%u \n", registerUser(pid, &entry), entry.psid); } /* catch control-c and kill signal */ signal(SIGINT, (void *) sig_int); signal(SIGTERM, (void *) sig_term); while (1) { ret = rxWSMMessage(pid, &rxmsg); /* Function to receive the Data from TX application */ if (ret > 0) { printf("Received WSMP Packet txpower= %d, rateindex=%d Packet No =#%llu#\n", rxpkt.chaninfo.txpower, rxpkt.chaninfo.rate, count++); rxWSMIdentity(&rxmsg, 0); //Identify the type of received Wave Short Message. if (!rxmsg.decode_status) { xml_print(rxmsg); /* call the parsing function to extract the contents of the received message */ } } else { blank++; } } }
void echoclient_test(void* args) { #ifdef _WIN32 WSADATA wsd; WSAStartup(0x0002, &wsd); #endif SOCKET_T sockfd = 0; int argc = 0; char** argv = 0; FILE* fin = stdin; FILE* fout = stdout; bool inCreated = false; bool outCreated = false; set_args(argc, argv, *static_cast<func_args*>(args)); if (argc >= 2) { fin = fopen(argv[1], "r"); inCreated = true; } if (argc >= 3) { fout = fopen(argv[2], "w"); outCreated = true; } if (!fin) err_sys("can't open input file"); if (!fout) err_sys("can't open output file"); tcp_connect(sockfd); SSL_METHOD* method = SSLv23_client_method(); SSL_CTX* ctx = SSL_CTX_new(method); set_certs(ctx); SSL* ssl = SSL_new(ctx); SSL_set_fd(ssl, sockfd); if (SSL_connect(ssl) != SSL_SUCCESS) EchoClientError(ctx, ssl, sockfd, "SSL_connect failed"); char send[1024]; char reply[1024]; while (fgets(send, sizeof(send), fin)) { int sendSz = (int)strlen(send) + 1; if (SSL_write(ssl, send, sendSz) != sendSz) EchoClientError(ctx, ssl, sockfd, "SSL_write failed"); if (strncmp(send, "quit", 4) == 0) { fputs("sending server shutdown command: quit!\n", fout); break; } if (SSL_read(ssl, reply, sizeof(reply)) > 0) fputs(reply, fout); } SSL_CTX_free(ctx); SSL_free(ssl); tcp_close(sockfd); fflush(fout); if (inCreated) fclose(fin); if (outCreated) fclose(fout); ((func_args*)args)->return_code = 0; }
/* * args_ok * * prepare args, check & parse user args, display error and * help message if neccessary * * result: TRUE, if all args ok and no request for HELP or * LICENSE has been detected */ static BOOL args_ok(int argc, char *argv[]) { struct arglist *hscdepp_args; /* argument structure */ BOOL arg_help = FALSE; BOOL arg_license = FALSE; BOOL ok = FALSE; /* create arg-table */ hscdepp_args = prepare_args ("HSCDEPP_ARGS", "FILE/T", &makefile, "makefile to update", "PRJFILE/T/K", &prjfile, "project file", "NAMEALL/T/K", &nameall, "name for `all_hsc' rule", "VERBOSE/S", &verbose, "verbose output", "NOBACKUP/S", &nobackup, "do not backup makefile", "NOTAGLINES/S", ¬aglines, "do not write taglines", "-DEBUG/S", &debug, "enable debugging output", "HELP=?=-h=--help/S", &arg_help, "display this text", "LICENSE/S", &arg_license, "display license", NULL); ok = (hscdepp_args != NULL); /* set & test args */ if (ok) { ok = set_args(argc, argv, hscdepp_args); /* display argument error message */ if (!ok) { pargerr(); set_return_code(RC_ERROR); } else if (arg_help || arg_license) { /* * display help or license text */ fprintf_prginfo(stderr); if (arg_help) fprintf_arghelp(stderr, hscdepp_args); else show_license(); set_return_code(RC_WARN); ok = FALSE; } else { /* auto-enable verbose in debug-mode */ if (debug) verbose = TRUE; /* display copyright in verbose-mode */ if (verbose) fprintf_prginfo(stderr); /* set default-parameters if neccessary */ if (!prjfile) { prjfile = DEFAULT_PROJECT; if (verbose) fprintf(stderr, HD "%s: using default project-file\n", prjfile); } if (!nameall) { nameall = DEFAULT_NAMEALL; } /* debugging control output */ D( if (makefile) { fprintf(stderr, DHD "makefile=`%s'\n", makefile); fprintf(stderr, DHD "makefile=DEFAULT\n"); fprintf(stderr, DHD "prjfile =`%s'\n", prjfile); fprintf(stderr, DHD "nameall =`%s'\n", nameall); } ); } /* release mem used by args */ free_args(hscdepp_args); }
int sporth_oscmorph4(sporth_stack *stack, void *ud) { plumber_data *pd = ud; SPFLOAT out; sporth_oscmorph *oscmorph; switch(pd->mode) { case PLUMBER_CREATE: #ifdef DEBUG_MODE fprintf(stderr, "oscmorph: Creating\n"); #endif oscmorph = malloc(sizeof(sporth_oscmorph)); sp_oscmorph_create(&oscmorph->data); oscmorph->nft = 4; oscmorph->ft = malloc(sizeof(sp_ftbl *) * 4); oscmorph->ftname = malloc(sizeof(char *) * 4); plumber_add_ugen(pd, SPORTH_OSCMORPH4, oscmorph); if(sporth_check_args(stack, "ffffssss") != SPORTH_OK) { fprintf(stderr,"Not enough arguments for oscmorph\n"); stack->error++; return PLUMBER_NOTOK; } get_strings(stack, oscmorph); pop_args(stack, oscmorph); if(search_for_ft(pd, oscmorph) == PLUMBER_NOTOK) { stack->error++; return PLUMBER_NOTOK; } sporth_stack_push_float(stack, 0); free_strings(oscmorph); break; case PLUMBER_INIT: #ifdef DEBUG_MODE fprintf(stderr, "oscmorph: Initialising\n"); #endif oscmorph = pd->last->ud; get_strings(stack, oscmorph); pop_args(stack, oscmorph); sp_oscmorph_init(pd->sp, oscmorph->data, oscmorph->ft, oscmorph->nft, oscmorph->phase); sporth_stack_push_float(stack, 0); free_strings(oscmorph); break; case PLUMBER_COMPUTE: oscmorph = pd->last->ud; pop_args(stack, oscmorph); set_args(oscmorph); sp_oscmorph_compute(pd->sp, oscmorph->data, NULL, &out); sporth_stack_push_float(stack, out); break; case PLUMBER_DESTROY: oscmorph = pd->last->ud; free(oscmorph->ftname); free(oscmorph->ft); sp_oscmorph_destroy(&oscmorph->data); free(oscmorph); break; default: fprintf(stderr, "oscmorph: Unknown mode!\n"); break; } return PLUMBER_OK; }
void client_test(void* args) { #ifdef _WIN32 WSADATA wsd; WSAStartup(0x0002, &wsd); #endif SOCKET_T sockfd = 0; int argc = 0; char** argv = 0; set_args(argc, argv, *static_cast<func_args*>(args)); tcp_connect(sockfd); #ifdef NON_BLOCKING tcp_set_nonblocking(sockfd); #endif SSL_METHOD* method = TLSv1_client_method(); SSL_CTX* ctx = SSL_CTX_new(method); set_certs(ctx); SSL* ssl = SSL_new(ctx); SSL_set_fd(ssl, sockfd); #ifdef NON_BLOCKING NonBlockingSSL_Connect(ssl, ctx, sockfd); #else // if you get an error here see note at top of README if (SSL_connect(ssl) != SSL_SUCCESS) ClientError(ctx, ssl, sockfd, "SSL_connect failed"); #endif showPeer(ssl); const char* cipher = 0; int index = 0; char list[1024]; strncpy(list, "cipherlist", 11); while ( (cipher = SSL_get_cipher_list(ssl, index++)) ) { strncat(list, ":", 2); strncat(list, cipher, strlen(cipher) + 1); } printf("%s\n", list); printf("Using Cipher Suite: %s\n", SSL_get_cipher(ssl)); char msg[] = "hello yassl!"; if (SSL_write(ssl, msg, sizeof(msg)) != sizeof(msg)) ClientError(ctx, ssl, sockfd, "SSL_write failed"); char reply[1024]; int input = SSL_read(ssl, reply, sizeof(reply)); if (input > 0) { reply[input] = 0; printf("Server response: %s\n", reply); } #ifdef TEST_RESUME SSL_SESSION* session = SSL_get_session(ssl); SSL* sslResume = SSL_new(ctx); #endif SSL_shutdown(ssl); SSL_free(ssl); tcp_close(sockfd); #ifdef TEST_RESUME tcp_connect(sockfd); SSL_set_fd(sslResume, sockfd); SSL_set_session(sslResume, session); if (SSL_connect(sslResume) != SSL_SUCCESS) ClientError(ctx, sslResume, sockfd, "SSL_resume failed"); showPeer(sslResume); if (SSL_write(sslResume, msg, sizeof(msg)) != sizeof(msg)) ClientError(ctx, sslResume, sockfd, "SSL_write failed"); input = SSL_read(sslResume, reply, sizeof(reply)); if (input > 0) { reply[input] = 0; printf("Server response: %s\n", reply); } SSL_shutdown(sslResume); SSL_free(sslResume); tcp_close(sockfd); #endif // TEST_RESUME SSL_CTX_free(ctx); ((func_args*)args)->return_code = 0; }
/* * args_ok * * prepare args, check & parse user args, display error and * help message if neccessary * * result: TRUE, if all args ok */ BOOL args_ok(HSCPRC * hp, int argc, char *argv[]) { BOOL ok; /* return value */ DLLIST *ignore_list = NULL; /* dummy */ EXPSTR *destdir = init_estr(32); /* destination dir */ EXPSTR *rel_destdir = init_estr(32); /* relative destination dir */ EXPSTR *kack_name = init_estr(0); /* temp. str for outfilename */ struct arglist *hsc_args; /* argument structure */ arg_hp = hp; arg_mode_CB(DEFAULT_MODE_STR); /* create arg-table */ hsc_args = prepare_args("HSC_ARGS", /* file args */ "FROM/M", &incfile, "include- and input-file(s)", "TO/K", &arg_outfname, "output file (default: stdout)", "PRJFILE/T/K", &prjfilename, "project file (default: none)", "PREFSFILE/T/K", &prefsfilename, "syntax preferences (default: hsc.prefs)", "MSGFILE=MF/T/K", &msgfilename, "message file (default: stderr)", "MSGFORMAT/T/K", &msg_format, "how to display message", /* numeric */ "MAXERR/N/K", &max_error, "max. number of errors (default: 20)", "EXTENSION/T/K", &arg_extension, "output-file-extension (default: " DEFAULT_EXTENSION ")", "DEFINE=DEF/T/K/M", &define_list, "define global attribute", "IGNORE=IGN/N/K/M/$", arg_ignore_CB, &ignore_list, "ignore message number", "MODE/E/K/$", arg_mode_CB, MODE_ENUMSTR, &arg_mode, "mode for syntax check (" MODE_ENUMSTR ")", "QUOTESTYLE=QS/E/K", QMODE_ENUMSTR, &arg_quotemode, "defines how quotes appear (" QMODE_ENUMSTR ")", #if 0 "ENTITYSTYLE=ES/E/K", EMODE_ENUMSTR, &entmode, "defines how special chars. appear (" EMODE_ENUMSTR ")", /* switches */ #endif "COMPACT=CO/S", &arg_compact, "strip useless LFs and white-spaces", "GETSIZE/S", &arg_getsize, "get width and height of images", "MSGANSI/S", &msg_ansi, "use ansi-sequences in messages", "RPLCENT=RE/S", &arg_rplc_ent, "replace special characters", "RPLCQUOTE=RQ/S", &arg_rplc_quote, "replace quotes in text by `"'", "SMARTENT=SA/S", &arg_smart_ent, "replace special entities (`&<>\"')", "JENS/S", &arg_jens, "don't try this at home", "STRIPCOMMENT=SC/S", &arg_strip_cmt, "strip SGML-comments", "STRIPEXTERNAL=SX/S", &arg_strip_ext, "strip tags with external URIs", "STRIPTAGS=ST/K", &arg_striptags, "tags to be stripped", "ICONBASE/T/K", &arg_iconbase, "base-uri for icon-entities", "STATUS/E/K/$", arg_status_CB, STATUS_ENUM_STR, &disp_status, "status message (" STATUS_ENUM_STR ")", "-DEBUG/S", &arg_debug, "enable debugging output", /* help */ "HELP=?/S", &arg_help, "display this text", "LICENSE/S", &arg_license, "display license", NULL); /* remove dummy list TODO: this sucks */ del_dllist(ignore_list); ok = (hsc_args != NULL); /* set & test args */ if (ok) { BOOL use_stdout = FALSE; /* flag: use stdout as output-file */ ok = set_args(argc, argv, hsc_args); /* display help, if requested vie HELP switch, or no * input to pipe or read is passed */ ok &= (!arg_help && (arg_pipe_in || (incfile && dll_first(incfile)))); if (arg_license) { /* display license text */ fprintf_prginfo(stderr); show_license(); set_return_code(RC_WARN); } else if (!ok) { /* display help, if error in args or HELP-switch set */ fprintf_prginfo(stderr); fprintf_arghelp(stderr, hsc_args); set_return_code(RC_WARN); } else { BOOL fnsux = FALSE; /* flag: TRUE = can't evaluate out-filename */ /* set debugging switch */ hsc_set_debug(hp, arg_debug); /* autoset depending options */ if (hsc_get_debug(hp)) disp_status = STATUS_VERBOSE; /* set default options */ if (!arg_extension) arg_extension = DEFAULT_EXTENSION; /* disable ID-warning if no project-file */ if (!prjfilename) hsc_set_msg_ignore(hp, MSG_NO_DOCENTRY, TRUE); /* compute name of input file */ arg_inpfname = NULL; if (dll_first(incfile) && !arg_pipe_in) { /* use last FROM as input file */ arg_inpfname = dln_data(dll_last(incfile)); set_estr(inpfilename, arg_inpfname); /* get path part of inputfilename as relative * destination directory */ get_fpath(rel_destdir, arg_inpfname); /* TODO: set reldir when including first file */ /* TODO: find out why the above TODO is there */ /* remove input filename from incfile */ del_dlnode(incfile, dll_last(incfile)); D(fprintf(stderr, DHSC "input : use `%s'\n" DHSC "reldir: use `%s'\n", estr2str(inpfilename), estr2str(rel_destdir))); } /* display include files */ D( { DLNODE * nd = dll_first(incfile); while (nd) { fprintf(stderr, DHSC "includ: use `%s'\n", ( STRPTR) dln_data(nd)); nd = dln_next(nd); } } ); /* * if no output-filename given, * outfilename stays NULL. this let open_output * open stdout as output-file */ if (arg_outfname) { /* check, if last char of outputfilename is a * directory separator; if so, use the filename * as destination directory */ if (arg_outfname) { UBYTE lastch = 0; /* get last char of outfname to determine * if it's a directory */ if (strlen(arg_outfname)) lastch = arg_outfname[strlen(arg_outfname) - 1]; #ifdef AMIGA /* for Amiga, execpt empty string for current dir */ if (!lastch) { lastch = (PATH_SEPARATOR[0]); D(fprintf(stderr, DHSC "AMIGA: use current dir\n")); } #endif if (strchr(PATH_SEPARATOR, lastch)) { /* use outfilename as destdir */ set_estr(destdir, arg_outfname); arg_outfname = NULL; D(fprintf(stderr, DHSC "output: use `%s' as destdir\n", estr2str(destdir))); } else if (arg_inpfname) { /* output-filename already specified */ /* separate it to destdir + reldir + name */ EXPSTR *kack_destdir = init_estr(0); EXPSTR *kack_reldir = init_estr(0); STRPTR inp_reldir = estr2str(rel_destdir); STRPTR out_reldir = NULL; STRPTR ou2_reldir = NULL; get_fname(kack_name, arg_outfname); get_fpath(kack_destdir, arg_outfname); /* check corresponding dirs for * consistency: check if last strlen(rel_destdir) * chars are equal */ out_reldir = estr2str(kack_destdir); ou2_reldir = out_reldir; out_reldir = out_reldir + (strlen(out_reldir) - strlen(inp_reldir)); if (out_reldir[0]) { /* search for next dir-sparator backwards */ /* (this ones only needed for a smart error message) */ while ((out_reldir != ou2_reldir) && (!strchr(PATH_SEPARATOR, out_reldir[0])) ) { out_reldir--; } out_reldir++; } D(fprintf(stderr, DHSC "corr_inp: `%s'\n" DHSC "corr_out: `%s'\n", inp_reldir, out_reldir) ); /* check if correspondig relative in/out-dirs * are equal */ if (!fnamecmp(inp_reldir, out_reldir)) { /* they match.. */ STRPTR tmp_name = NULL; /* copy of kack_nam */ /* cut corresponding chars */ get_left_estr(kack_destdir, kack_destdir, estrlen(kack_destdir) - strlen(out_reldir)); set_estr(kack_reldir, inp_reldir); D(fprintf(stderr, DHSC "kack_dst: `%s'\n" DHSC "kack_rel: `%s'\n" DHSC "kack_nam: `%s'\n", estr2str(kack_destdir), estr2str(kack_reldir), estr2str(kack_name)) ); /* just copy these values where they are * expected to be */ estrcpy(destdir, kack_destdir); estrcpy(rel_destdir, kack_reldir); /* create output filename */ tmp_name = strclone(estr2str(kack_name)); estrcpy(kack_name, kack_destdir); estrcat(kack_name, kack_reldir); app_estr(kack_name, tmp_name); ufreestr(tmp_name); arg_outfname = estr2str(kack_name); } else { /* unmatched corresponding dirs */ fprintf(stderr, "unmatched corresponding relative directories:\n" " input `%s'\n output `%s'\n", inp_reldir, out_reldir); ok = FALSE; } /* free temp. vars */ del_estr(kack_reldir); del_estr(kack_destdir); } } if (arg_outfname) { /* set outputfilename with value passed iwithin args */ outfilename = init_estr(32); set_estr(outfilename, arg_outfname); D(fprintf(stderr, DHSC "output: set to `%s'\n", estr2str(outfilename))); } else { if (!arg_pipe_in) { /* no outfilename given */ /* ->outfilename = destdir + inpfilename + ".html" */ /* link destdir & input filename */ outfilename = init_estr(32); link_fname(outfilename, estr2str(destdir), arg_inpfname); if (strcmp(arg_extension, ".")) set_fext(outfilename, arg_extension); D(fprintf(stderr, DHSC "output: concat destdir+inpfile+`.%s'\n" DHSC "output: set to `%s'\n", arg_extension, estr2str(outfilename))); } else fnsux = TRUE; } if (fnsux) { /* no way to find out output filename */ status_error("unable to evaluate output filename\n"); arg_outfname = NULL; ok = FALSE; } } else { D(fprintf(stderr, DHSC "output: use stdout\n")); use_stdout = TRUE; } if (!ok) set_return_code(RC_ERROR); } if (ok) { if (arg_iconbase) hsc_set_iconbase(hp, arg_iconbase); if (!use_stdout) hsc_set_filename_document(hp, estr2str(outfilename)); } /* display argument error message */ if (!ok) { /* NOTE: no strclone() is used on outfilename, if an * error already occured within set_args(). therefore, * you must not call ufreestr( outfilename ) */ pargerr(); arg_outfname = NULL; set_return_code(RC_ERROR); } else { EXPSTR *tmp_fname = init_estr(32); /* filename only part */ fileattr_str = init_estr(64); if (outfilename) get_fname(tmp_fname, estr2str(outfilename)); set_dest_attribs(hp, estr2str(rel_destdir), estr2str(tmp_fname)); if (!arg_pipe_in) { if (outfilename) get_fname(tmp_fname, estr2str(outfilename)); else clr_estr(tmp_fname); set_source_attribs(hp, estr2str(rel_destdir), estr2str(tmp_fname)); } else set_source_attribs(hp, NULL, NULL); D( { HSCMSG_ID i; fprintf(stderr, "\n" DHSC "input : `%s'\n", estr2str(inpfilename)); fprintf(stderr, DHSC "output: `%s'\n", get_outfilename()); fprintf(stderr, DHSC "destdr: `%s'\n", estr2str(destdir)); fprintf(stderr, DHSC "reldst: `%s'\n", estr2str(rel_destdir)); if (prjfilename) fprintf(stderr, DHSC "projct: `%s'\n", prjfilename); if (!use_stdout) fprintf(stderr, DHSC "procss: `%s'\n", estr2str(outfilename)); fprintf(stderr, DHSC "ignore:"); for (i = 0; i < MAX_MSGID; i++) if (hsc_get_msg_ignore(hp, i)) fprintf(stderr, " %lu", i); fprintf(stderr, "\n"); } ); del_estr(tmp_fname); }
/* * args_ok * * prepare args, check & parse user args, display error and * help message if neccessary * * result: TRUE, if all args ok and no request for HELP or * LICENSE has been detected */ static BOOL args_ok(int argc, char *argv[]) { struct arglist *hscpitt_args; /* argument structure */ BOOL arg_help = FALSE; BOOL arg_license = FALSE; BOOL ok = FALSE; /* create arg-table */ hscpitt_args = prepare_args ("HSCPITT_ARGS", "COMMAND/E", COMMAND_ENUMSTR, &command, "command to perform (" COMMAND_ENUMSTR ")", "ARG/T/M", &command_arglist, "command argument(s)", "PRJFILE/T/K", &prjfile, "project file", "FORCE/S", &force, "disable certain checks", "QUIET/S", &quiet, "act quietly", "-DEBUG/S", &debug, "enable debugging output", "HELP=?=-h=--help/S", &arg_help, "display this text", "LICENSE/S", &arg_license, "display license", NULL); ok = (hscpitt_args != NULL); /* set & test args */ if (ok) { ok = set_args(argc, argv, hscpitt_args); /* display argument error message */ if (!ok) { pargerr(); set_return_code(RC_ERROR); } else if (arg_help || arg_license) { /* * display help or license text */ fprintf_prginfo(stderr); if (arg_help) fprintf_arghelp(stderr, hscpitt_args); else show_license(); set_return_code(RC_WARN); ok = FALSE; } else { /* display copyright in verbose-mode */ if (!quiet) fprintf_prginfo(stderr); /* set default-parameters if neccessary */ if (!prjfile) { prjfile = DEFAULT_PROJECT; if (!quiet) { fprintf(stderr, HP "%s: using default project-file\n", prjfile); } } if (command) { /* debugging control output */ D( { fprintf(stderr, DHP "prjfile =`%s'\n", prjfile); fprintf(stderr, DHP "command =`%ld'\n", command); } ); } else { fprintf(stderr, "no command specified\n"); ok = FALSE; } }
void sinsp_chisel::on_init() { // // Done with the arguments, call init() // lua_getglobal(m_ls, "on_init"); if(!lua_isfunction(m_ls, -1)) { // // No on_init. // That's ok. Just return. // return; } if(lua_pcall(m_ls, 0, 1, 0) != 0) { // // Exception running init // const char* lerr = lua_tostring(m_ls, -1); string err = m_filename + ": error in init(): " + lerr; throw sinsp_exception(err); } if(m_new_chisel_to_exec == "") { if(!lua_isboolean(m_ls, -1)) { throw sinsp_exception(m_filename + " chisel error: wrong init() return value."); } if(!lua_toboolean(m_ls, -1)) { throw sinsp_exception("init() for chisel " + m_filename + " failed."); } } lua_pop(m_ls, 1); // // If the chisel called chisel.exec(), free this chisel and load the new one // if(m_new_chisel_to_exec != "") { free_lua_chisel(); load(m_new_chisel_to_exec); m_new_chisel_to_exec = ""; string args; for(uint32_t j = 0; j < m_argvals.size(); j++) { if(m_argvals[j].find(" ") == string::npos) { args += m_argvals[j]; } else { args += string("'") + m_argvals[j] + "'"; } if(j < m_argvals.size() - 1) { args += " "; } } m_argvals.clear(); set_args(args); on_init(); } }
static int CreateChildProcess(T waiter, std::string const& executable, std::vector<std::string> const& args, std::string const& logger, std::string const& input, bool secure) { auto outPipe = create_pipe(); auto errPipe = create_pipe(); Optional<file_descriptor_source> inputSource; if (!secure) { TC_LOG_TRACE(logger, "Starting process \"%s\" with arguments: \"%s\".", executable.c_str(), boost::algorithm::join(args, " ").c_str()); } // Start the child process child c = [&] { if (!input.empty()) { inputSource = file_descriptor_source(input); // With binding stdin return execute(run_exe(boost::filesystem::absolute(executable)), set_args(args), inherit_env(), bind_stdin(*inputSource), bind_stdout(file_descriptor_sink(outPipe.sink, close_handle)), bind_stderr(file_descriptor_sink(errPipe.sink, close_handle))); } else { // Without binding stdin return execute(run_exe(boost::filesystem::absolute(executable)), set_args(args), inherit_env(), bind_stdout(file_descriptor_sink(outPipe.sink, close_handle)), bind_stderr(file_descriptor_sink(errPipe.sink, close_handle))); } }(); file_descriptor_source outFd(outPipe.source, close_handle); file_descriptor_source errFd(errPipe.source, close_handle); auto outInfo = MakeTCLogSink([&](std::string msg) { TC_LOG_INFO(logger, "%s", msg.c_str()); }); auto outError = MakeTCLogSink([&](std::string msg) { TC_LOG_ERROR(logger, "%s", msg.c_str()); }); copy(outFd, outInfo); copy(errFd, outError); // Call the waiter in the current scope to prevent // the streams from closing too early on leaving the scope. int const result = waiter(c); if (!secure) { TC_LOG_TRACE(logger, ">> Process \"%s\" finished with return value %i.", executable.c_str(), result); } if (inputSource) inputSource->close(); return result; }
void Message::use_from_task(Task* task, size_t args) { set_caller(task->active()); set_args(args); stack_args_ = caller_->stack_back_position(args - 1); arguments_ = stack_args_; }