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