static int k_any(Ihandle *ih, int c) { switch(c) { case K_m: IupSetGlobal("PARENTDIALOG", "_MAIN_DIALOG_TEST_"); IupMessage("IupMessage Test", "Message Text\nSecond Line."); IupSetGlobal("PARENTDIALOG", NULL); break; case K_e: new_message("ERROR", NULL); break; case K_i: new_message("INFORMATION", NULL); break; case K_w: new_message("WARNING", "OKCANCEL"); break; case K_q: new_message("QUESTION", "YESNO"); break; case K_c: new_color(); break; case K_f: new_font(); break; case K_o: new_file("OPEN", 0); break; case K_O: new_file("OPEN", 1); break; case K_G: new_file("OPEN", 2); break; case K_s: new_file("SAVE", 0); break; case K_d: new_file("DIR", 0); break; case K_a: new_alarm(); break; case K_g: new_getfile(); break; case K_t: new_gettext(); break; case K_l: new_list(); break; case K_ESC: IupDestroy(ih); return IUP_IGNORE; } return IUP_DEFAULT; }
static void handle_error_msg(struct compiler *c, char *str) { int i, len; for (i = 0; str[i]; i++) { if (str[i] == '\n') { str[i] = 0; break; } if (str[i] == '\t') str[i] = ' '; } len = i; if (len == 0) return; for (i = 0; i < c->error_formats.count; i++) { const struct error_format *p = c->error_formats.ptrs[i]; PTR_ARRAY(m); if (!regexp_exec_sub(&p->re, str, len, &m, 0)) continue; if (!p->ignore) { struct message *msg = new_message(m.ptrs[p->msg_idx]); msg->file = p->file_idx < 0 ? NULL : xstrdup(m.ptrs[p->file_idx]); msg->u.location.line = p->line_idx < 0 ? 0 : atoi(m.ptrs[p->line_idx]); msg->u.location.column = p->column_idx < 0 ? 0 : atoi(m.ptrs[p->column_idx]); add_message(msg); } ptr_array_free(&m); return; } add_message(new_message(str)); }
void network_multiplexer_acceptclient_net(t_player *player, t_client *client) { char buffer[256]; t_log_message msg; bzero(buffer, 256); player->client = client; g_core.network->max_fd = (g_core.network->max_fd <= client->sock[TCP]) ? (client->sock[TCP] + 1) : g_core.network->max_fd; FD_SET(client->sock[TCP], &g_core.network->fdset); FD_SET(client->sock[TCP], &g_core.network->wfdset); sprintf(buffer, "{%d} Connection of client on %s", client->sock[TCP], client->get_host(client)); init_logging_message(&msg, "Network", buffer, INFORMATION); network_logging(g_core.network->log, &msg); g_core.network->list_client->push_front(g_core.network->list_client, player); if (client->sock[TCP] >= (int)g_core.network->array_player_size) { g_core.network->array_player_size *= 2; g_core.network->array_player = realloc(g_core.network->array_player, sizeof(t_player *) * g_core.network->array_player_size); } g_core.network->array_player[client->sock[TCP]] = player; g_core.network->send_queue->push_back(g_core.network->send_queue, new_message(client->sock[TCP], "BIENVENUE\n")); }
// A handler for the /ajax/send_message endpoint. static void ajax_send_message(struct mg_connection *conn, const struct mg_request_info *request_info) { struct message *message; struct session *session; char text[sizeof(message->text) - 1]; int is_jsonp; mg_printf(conn, "%s", ajax_reply_start); is_jsonp = handle_jsonp(conn, request_info); get_qsvar(request_info, "text", text, sizeof(text)); if (text[0] != '\0') { // We have a message to store. Write-lock the ringbuffer, // grab the next message and copy data into it. pthread_rwlock_wrlock(&rwlock); message = new_message(); // TODO(lsm): JSON-encode all text strings session = get_session(conn); assert(session != NULL); my_strlcpy(message->text, text, sizeof(text)); my_strlcpy(message->user, session->user, sizeof(message->user)); pthread_rwlock_unlock(&rwlock); } mg_printf(conn, "%s", text[0] == '\0' ? "false" : "true"); if (is_jsonp) { mg_printf(conn, "%s", ")"); } }
int new_reply(Router *router, Message *m, int toolid, MessageStatus st, MessageMode mode, int reqrepid, int pattern_id, MessageDestroy_fptr fptr) { int ret=0; ret=new_message(router,m,toolid,st,mode,pattern_id,fptr); if(-1 != ret) { RequestTool rt; pthread_mutex_lock(&router->bindings_mutex); rt.reqrepid=reqrepid; if (!Glist_search(&router->request_tool_list,&rt,(void *)compare_reqrepid_func)) ret=-1; // ERROR No request pending for this reply. else { m->type=REPLY; m->reqrepid=reqrepid; ret=0; // SUCCESS } pthread_mutex_unlock(&router->bindings_mutex); } return ret; }
PGconn * connect_to_db(char *conninfo) { static int refresh = 0; PGconn *pgconn = NULL; pgconn = PQconnectdb(conninfo); if (PQstatus(pgconn) != CONNECTION_OK) { refresh = 1; new_message(MT_standout | MT_delayed, " %s", PQerrorMessage(pgconn)); PQfinish(pgconn); return NULL; } else { /* * FIXME: I don't know how expensive this is but I don't know how to * get the header text to redisplay when it gets wipe out by the * above's susequent new_message() calls. The number of running * processes seems to printed a litle funny when it is 0 too. */ if (refresh == 1) { reset_display(); refresh = 0; } } return pgconn; }
// La funciĆ³n de entrada de un thread siempre debe tener este prototipo // pero esto no impide recibir argumentos "complejos" y devolver cualquier tipo // de resultado void* client_thread (void* ptr) { struct client_arg* arg; int i; message_t* msg; arg = (struct client_arg*) ptr; fprintf(logfile,"NEW client of type %d with period %d \n",arg->m_type, arg->period); for (i=0;i<arg->n_messages; i++) { if ( ( msg=new_message(arg->m_type ) ) == NULL ) { fprintf(stderr,"Error when creating message\n"); pthread_exit(NULL); } // Post message to mailbox mbox_post( arg->mbox, msg); // Wait for server to finish the work sys_sem_wait(msg->op_completed); // We can process and free the message process_answer(msg); free_message(msg); // Sleep for period seconds before the next message sleep(arg->period); } return NULL; }
static void* handle_receive(void* qp) { qpos_t* pointer = (qpos_t*)qp; if (pointer) { char buf[MESSAGE_LIMIT]; int n; size_t pos, used = 0; char skip = 0; struct pollfd poller; poller.fd = *pointer->cfd; poller.events = POLLRDNORM; int loop = 1; while(loop) { poll(&poller, 1, INFTIM); if (poller.revents & POLLRDNORM) { n = read(poller.fd, buf + used, MESSAGE_LIMIT - used); if (n <= 0) break; used += n; pos = 0; while (pos < used) { for (; pos < used && buf[pos] != '\n'; pos++); if (pos < used) { if (skip) { skip = 0; } else { new_message(buf, pos + 1); } used -= (pos + 1); memmove(buf, buf + pos + 1, used); } else if (pos == MESSAGE_LIMIT) { skip = 1; used = 0; } } } pthread_rwlock_rdlock(&global_lock); if (pointer->pos == QUEUE_BACKLOG) loop = 0; pthread_rwlock_unlock(&global_lock); } printf("HR: someone disconnected\n"); pthread_rwlock_wrlock(&global_lock); pointer->pos = QUEUE_BACKLOG; pthread_rwlock_unlock(&global_lock); } return NULL; }
static void send_server_message(const char *fmt, ...) { va_list ap; struct message *message; pthread_rwlock_wrlock(&rwlock); message = new_message(); message->user[0] = '\0'; // Empty user indicates server message va_start(ap, fmt); vsnprintf(message->text, sizeof(message->text), fmt, ap); va_end(ap); pthread_rwlock_unlock(&rwlock); }
int new_notification(Router *router, Message *m, int toolid, MessageStatus st, MessageMode mode, int pattern_id, MessageDestroy_fptr fptr) { int ret=0; ret=new_message(router,m,toolid,st,mode,pattern_id,fptr); if(-1 != ret) { m->type=NOTIFICATION; m->reqrepid=-1; ret=0; // SUCCESS } return ret; }
/** * @brief Callback called from control thread. * * This function is a callback called from control thread to change some parameters of * compression. * * @param[in] receiver pointer to the compress module * @param[in] msg message passed to callback * @returns response to the message */ static struct response *compress_change_callback(struct module *receiver, struct message *msg) { struct msg_change_compress_data *data = (struct msg_change_compress_data *) msg; compress_state_proxy *proxy = receiver->priv_data; /* In this case we are only changing some parameter of compression. * This means that we pass the parameter to compress driver. */ if(data->what == CHANGE_PARAMS) { platform_spin_lock(&proxy->spin); struct response *resp = NULL; for(unsigned int i = 0; i < proxy->ptr->state_count; ++i) { if(resp) { resp->deleter(resp); } struct msg_change_compress_data *tmp_data = (struct msg_change_compress_data *) new_message(sizeof(struct msg_change_compress_data)); tmp_data->what = data->what; strncpy(tmp_data->config_string, data->config_string, sizeof(tmp_data->config_string) - 1); resp = send_message_to_receiver(proxy->ptr->state[i], (struct message *) tmp_data); } platform_spin_unlock(&proxy->spin); free_message(msg); return resp; } else { struct compress_state_real *new_state; char config[1024]; strncpy(config, data->config_string, sizeof(config)); int ret = compress_init_real(&proxy->mod, config, &new_state); if(ret == 0) { struct compress_state_real *old = proxy->ptr; platform_spin_lock(&proxy->spin); proxy->ptr = new_state; platform_spin_unlock(&proxy->spin); compress_done_real(old); return new_response(RESPONSE_OK, NULL); } return new_response(RESPONSE_INT_SERV_ERR, NULL); } }
int new_request(Router *router, Message *m, int toolid, MessageStatus st, MessageMode mode, int pattern_id, MessageDestroy_fptr fptr) { int ret=0; ret=new_message(router,m,toolid,st,mode,pattern_id,fptr); if(-1 != ret) { m->type=REQUEST; pthread_mutex_lock(&router->bindings_mutex); m->reqrepid=router->request_reply_counter++; pthread_mutex_unlock(&router->bindings_mutex); ret=0; // SUCCESS } return ret; }
void NLog::append_to_log(LogMessage::Type type, bool fromServer, const QString & message) { QString header = "[ %1 ][ %2 ] "; QString msg; header = header.arg(QDateTime::currentDateTime().toString("yyyy-MM-dd HH:mm:ss")); header = header.arg(fromServer ? "Server" : "Client"); msg = message; msg.replace('\n', QString("\n%1").arg(header)); msg.prepend(header); emit new_message(msg, type); if(type == LogMessage::EXCEPTION) emit new_exception(message); }
int main(int argc, char *argv[]) { (void) argc; (void) argv; ssize_t res; if(!new_message(&msg)){ res = write(STDERR_FILENO, cant_alloc_msg, sizeof(cant_alloc_msg)); (void) res; return 1; } if(!init_speech()){ res = write(STDERR_FILENO, cant_init_msg, sizeof(cant_init_msg)); (void) res; return 1; } res = write(STDOUT_FILENO, "\0", 1); if(res < 0){ //would write problem message, but we can't send anyway return 1; } while(1){ if(!read_message(STDIN_FILENO, msg)){ res = write(STDERR_FILENO, cant_read_msg, sizeof(cant_read_msg)); (void) res; break; } say(str_from_msg(msg)); while(!spoken(0.0f)){ usleep(200000); } res = write(STDOUT_FILENO, "\0", 1); if(res < 0){ //would write problem message, but we can't send anyway break; } } close_speech(); cleanup_speech(); return 0; }
static int mbox_quick_get_message (mu_mailbox_t mailbox, mu_message_qid_t qid, mu_message_t *pmsg) { int status; mbox_data_t mud = mailbox->data; mbox_message_t mum; mu_off_t offset; if (mailbox == NULL || qid2off (qid, &offset) || !(mailbox->flags & MU_STREAM_QACCESS)) return EINVAL; if (mud->messages_count == 0) { status = mbox_scan1 (mailbox, offset, 0); if (status != 0) return status; if (mud->messages_count == 0) return MU_ERR_NOENT; } /* Quick access mode retrieves only one message */ mum = mud->umessages[0]; /* Check if we already have it and verify if it is the right one. */ if (mum->message) { char *vqid; status = mu_message_get_qid (mum->message, &vqid); if (status) return status; status = strcmp (qid, vqid); free (vqid); if (status) return MU_ERR_EXISTS; if (pmsg) *pmsg = mum->message; return 0; } return new_message (mailbox, mum, pmsg); }
static int mbox_get_message (mu_mailbox_t mailbox, size_t msgno, mu_message_t *pmsg) { int status; mbox_data_t mud = mailbox->data; mbox_message_t mum; /* Sanity checks. */ if (pmsg == NULL) return MU_ERR_OUT_PTR_NULL; if (mud == NULL) return EINVAL; /* If we did not start a scanning yet do it now. */ if (mud->messages_count == 0) { status = mbox_scan0 (mailbox, 1, NULL, 0); if (status != 0) return status; } /* Second sanity: check the message number. */ if (!(mud->messages_count > 0 && msgno > 0 && msgno <= mud->messages_count)) return EINVAL; mum = mud->umessages[msgno - 1]; /* Check if we already have it. */ if (mum->message) { if (pmsg) *pmsg = mum->message; return 0; } MU_DEBUG2 (mailbox->debug, MU_DEBUG_TRACE1, "mbox_get_message (%s, %lu)\n", mud->name, (unsigned long) msgno); return new_message (mailbox, mum, pmsg); }
ExprPtr IoBlock::call(ArgList args, std::size_t num_args) { if (!empty()) { char const* errorPoint = "before eval"; IoMessage* m; try { m = new_message(io_target, "IoBlock"); errorPoint = "while adding args"; for (int i = 0; i < num_args; ++i) add_arg(m, args[i]); errorPoint = "on activate"; IoObject* io_obj = activate(m); errorPoint = "create IoObjectExpr"; TypeIndex from_type = FromIoTypeInfo::create_index(get_type_name(io_obj)); if (type_system->has_type(from_type)) return create_expr(io_obj, from_type); else return Term<IoObject*>::create(io_obj); } catch (Iocaste::ScriptException const& exc) { // TODO: assoc addn'l info w/exp. throw; } // TODO: Create LikeMagic exception object. catch (std::exception const& e) { throw Iocaste::IoStateError(io_block, std::string() + "Error in IoBlock " + errorPoint + ": " + e.what(), m); } } else { throw std::logic_error("Tried to eval an empty block."); } }
int shutdown_server() { message_t* msg; serv_up = 0; // Create NONE message if ( ( msg=new_message(NONE ) ) == NULL ) { fprintf(logfile,"Error when creating NONE message\n"); return -1; } // Post it message to mailbox mbox_post( mbox, msg); // Wait for server to finish the work counting_sem_wait(msg->op_completed); // Ignore answer if (msg != NULL) free_message(msg); return 0; }
static void socket_message(struct skynet_context *ctx, struct package *P, const struct skynet_socket_message * smsg) { switch (smsg->type) { case SKYNET_SOCKET_TYPE_CONNECT: if (P->init == 0 && smsg->id == P->fd) { skynet_send(ctx, 0, P->manager, PTYPE_TEXT, 0, "SUCC", 4); P->init = 1; } break; case SKYNET_SOCKET_TYPE_CLOSE: case SKYNET_SOCKET_TYPE_ERROR: if (P->init == 0 && smsg->id == P->fd) { skynet_send(ctx, 0, P->manager, PTYPE_TEXT, 0, "FAIL", 4); P->init = 1; } if (smsg->id != P->fd) { skynet_error(ctx, "Invalid fd (%d), should be (%d)", smsg->id, P->fd); } else { // todo: log when SKYNET_SOCKET_TYPE_ERROR response(ctx, P); service_exit(ctx, P); } break; case SKYNET_SOCKET_TYPE_DATA: new_message(P, (const uint8_t *)smsg->buffer, smsg->ud); skynet_free(smsg->buffer); response(ctx, P); break; case SKYNET_SOCKET_TYPE_WARNING: skynet_error(ctx, "Overload on %d", P->fd); break; default: // ignore break; } }
void Environment::run(RunningContext *context) { const Instruction &ins = m_ipos; m_context = context; if (!context) { m_running = false; } else if (!m_running) { clear_vstore(); TRACE_PRINTF(TRACE_VM, TRACE_INFO, "Entering running state with %p\n", context); m_running = true; const SourcePos *last_pos = NULL; // used for debug output below. const Instruction *ipos; while (m_context && (ipos = m_context->next())) { size_t output = -1; size_t expected = -1; # define CHECK_STACK(in, out) TRACE_OUT(TRACE_VM, TRACE_SPAM) {\ assert(m_context->stack_count() >= (size_t)(in)); \ if ((out) != -1) { assert((long)(expected = m_context->stack_count() - (size_t)(in) + (size_t)(out)) >= 0); } \ tprintf("Stack info: before(%d), in(%d), out(%d), expected(%d)\n", (int)m_context->stack_count(), (int)(in), (int)(out), (int)expected); \ output = (out); \ } m_ipos = *ipos; TRACE_DO(TRACE_VM, TRACE_INFO) { const SourcePos &pos = m_context->m_instructions->source_pos(ipos); if (!last_pos || *last_pos != pos) tprintf("Source Position: %s:%d:%d (%s)\n", pos.file.c_str(), (int)pos.line_num, (int)pos.column, pos.annotation.c_str()); last_pos = &pos; } TRACE_OUT(TRACE_VM, TRACE_SPAM) { tprintf("Instruction: %s@%d\n", inspect(ins).c_str(), (int)(ipos - &*m_context->instructions().begin()) ); tprintf("Stack: %d deep", (int)m_context->stack_count()); const Value *it; for (it = m_context->stack_begin(); it != m_context->stack_pos(); it++) { tprintf("\n %s", inspect(*it).c_str()); } tprintf(" <--\n"); } switch(ins.instruction) { case NOP: CHECK_STACK(0, 0); break; case DEBUGGER: CHECK_STACK(0, 0); { String *action = ptr<String>(ins.arg1); if (*action == "interrupt") { DO_DEBUG __asm__("int3"); } else if (*action == "trace_enable") { trace_mute = false; } else if (*action == "trace_disable") { trace_mute = true; } } break; case POP: CHECK_STACK(1, 0); m_context->pop(); break; case PUSH: CHECK_STACK(0, 1); m_context->push(ins.arg1); break; case SWAP: { CHECK_STACK(2, 2); Value tmp1 = m_context->top(); m_context->pop(); Value tmp2 = m_context->top(); m_context->pop(); m_context->push(tmp1); m_context->push(tmp2); } break; case DUP_TOP: CHECK_STACK(1, 2); m_context->push(m_context->top()); break; case IS: { CHECK_STACK(1, 1); Value res = bvalue(ins.arg1 == m_context->top()); m_context->pop(); m_context->push(res); } break; case IS_EQ: { CHECK_STACK(2, 1); Value first = m_context->top(); m_context->pop(); Value second = m_context->top(); m_context->pop(); m_context->push(bvalue(first == second)); } break; case IS_NOT: { CHECK_STACK(1, 1); Value res = bvalue(ins.arg1 != m_context->top()); m_context->pop(); m_context->push(res); } break; case IS_NOT_EQ:{ CHECK_STACK(2, 1); Value first = m_context->top(); m_context->pop(); Value second = m_context->top(); m_context->pop(); m_context->push(bvalue(first != second)); } break; case JMP: CHECK_STACK(0, 0); GC::safe_point(); m_context->jump(ins.cache.machine_num); break; case JMP_IF: CHECK_STACK(1, 0); GC::safe_point(); if (is_truthy(m_context->top())) m_context->jump(ins.cache.machine_num); m_context->pop(); break; case JMP_IF_NOT: CHECK_STACK(1, 0); GC::safe_point(); if (!is_truthy(m_context->top())) m_context->jump(ins.cache.machine_num); m_context->pop(); break; case LEXICAL_CLEAN_SCOPE: { CHECK_STACK(0, 0); VariableFrame *frame = new_variable_frame(m_context->m_instructions); m_context->new_scope(frame); } break; case LEXICAL_LINKED_SCOPE: { CHECK_STACK(0, 0); VariableFrame *frame = new_variable_frame(m_context->m_instructions); frame->link_frame(m_context->m_lexicalvars); m_context->new_scope(frame); } break; case FRAME_GET: { CHECK_STACK(0, 1); size_t frameid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "Getting frame var %s (%d)\n", ptr<String>(ins.arg1)->c_str(), (int)frameid); m_context->push(m_context->get_framevar(frameid)); } break; case FRAME_SET: { CHECK_STACK(1, 0); size_t frameid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "Setting frame var %s (%d) to: %s\n", ptr<String>(ins.arg1)->c_str(), (int)frameid, inspect(m_context->top()).c_str()); m_context->set_framevar(frameid, m_context->top()); m_context->pop(); } break; case LOCAL_GET: { CHECK_STACK(0, 1); size_t localid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "Getting local var %s (%d)\n", ptr<String>(ins.arg1)->c_str(), (int)localid); m_context->push(m_context->get_localvar(localid)); } break; case LOCAL_SET: { CHECK_STACK(1, 0); size_t localid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "Setting local var %s (%d) to: %s\n", ptr<String>(ins.arg1)->c_str(), (int)localid, inspect(m_context->top()).c_str()); m_context->set_localvar(localid, m_context->top()); m_context->pop(); } break; case LEXICAL_GET: { CHECK_STACK(0, 1); size_t depth = ins.arg1.machine_num; size_t localid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "lexical_get %u@%u: %i\n", (unsigned)localid, (unsigned)depth, type(m_context->get_lexicalvar(localid, depth))); if (depth == 0) m_context->push(m_context->get_lexicalvar(localid)); else m_context->push(m_context->get_lexicalvar(localid, depth)); } break; case LEXICAL_SET: { CHECK_STACK(1, 0); size_t depth = ins.arg1.machine_num; size_t localid = (size_t)ins.cache.machine_num; TRACE_PRINTF(TRACE_VM, TRACE_SPAM, "lexical_set %u@%u: %i\n", (unsigned)localid, (unsigned)depth, type(m_context->top())); if (depth == 0) m_context->set_lexicalvar(localid, m_context->top()); else m_context->set_lexicalvar(localid, depth, m_context->top()); m_context->pop(); } break; case CHANNEL_NEW: { CHECK_STACK(0, 1); const Value &octx = vstore(value(m_context)); RunnableContext *nctx = new_context(octx); nctx->jump(ins.cache.machine_num); m_context->push(value(nctx)); clear_vstore(); } break; case CHANNEL_SPECIAL: CHECK_STACK(0, 1); m_context->push(special_channel(*ptr<String>(ins.arg1))); break; case CHANNEL_SEND: { CHECK_STACK(3, -1); GC::safe_point(); const Value &val = vstore(m_context->top()); m_context->pop(); const Value &ret = vstore(m_context->top()); m_context->pop(); const Value &channel = vstore(m_context->top()); m_context->pop(); // A context that's been channel_sended from should never be returned to, // so invalidate it. m_context->invalidate(); channel_send(this, channel, val, ret); clear_vstore(); } break; case CHANNEL_CALL:{ CHECK_STACK(2, -1); GC::safe_point(); const Value &val = vstore(m_context->top()); m_context->pop(); const Value &channel = vstore(m_context->top()); m_context->pop(); const Value &ret = vstore(value(m_context)); channel_send(this, channel, val, ret); clear_vstore(); } break; case CHANNEL_RET:{ CHECK_STACK(2, -1); const Value &val = vstore(m_context->top()); m_context->pop(); const Value &channel = vstore(m_context->top()); m_context->pop(); // A context that's been channel_reted from should never be returned to, // so invalidate it. m_context->invalidate(); channel_send(this, channel, val, value(&no_return_ctx)); clear_vstore(); } break; case MESSAGE_NEW: { long long id = ins.cache.machine_num; long long sysarg_count = ins.arg2.machine_num, sysarg_counter = sysarg_count - 1; long long arg_count = ins.arg3.machine_num, arg_counter = arg_count - 1; CHECK_STACK(sysarg_count + arg_count, 1); Message *msg = new_message(id, sysarg_count, arg_count); while (arg_count > 0 && arg_counter >= 0) { msg->args()[arg_counter] = m_context->top(); m_context->pop(); --arg_counter; } while (sysarg_count > 0 && sysarg_counter >= 0) { msg->sysargs()[sysarg_counter] = m_context->top(); m_context->pop(); --sysarg_counter; } m_context->push(value(msg)); } break; case MESSAGE_SPLAT: { CHECK_STACK(2, 1); const Tuple &tuple = *ptr<Tuple>(m_context->top()); m_context->pop(); const Message &msg = *ptr<Message>(m_context->top()); m_context->pop(); Message *nmsg = new_message(msg.m_id, msg.sysarg_count(), msg.arg_count() + tuple.size()); std::copy(msg.sysargs(), msg.sysargs_end(), nmsg->sysargs()); std::copy(msg.args(), msg.args_end(), nmsg->args()); std::copy(tuple.begin(), tuple.end(), nmsg->args() + msg.arg_count()); m_context->push(value(nmsg)); } break; case MESSAGE_ADD: { long long count = ins.arg1.machine_num, counter = 0; CHECK_STACK(1 + count, 1); const Message &msg = *ptr<Message>(*(m_context->stack_pos() - 1 - count)); Message *nmsg = new_message(msg.m_id, msg.sysarg_count(), msg.arg_count() + count); std::copy(msg.sysargs(), msg.sysargs_end(), nmsg->sysargs()); std::copy(msg.args(), msg.args_end(), nmsg->args()); Message::iterator out = nmsg->args() + msg.arg_count(); while (count > 0 && counter < count) { *out++ = m_context->top(); m_context->pop(); ++counter; } m_context->pop(); // this is the message we pulled directly off the stack before. m_context->push(value(nmsg)); } break; case MESSAGE_COUNT: CHECK_STACK(1, 2); m_context->push(value((long long)ptr<Message>(m_context->top())->arg_count())); break; case MESSAGE_IS: CHECK_STACK(1, 2); m_context->push(bvalue(ptr<Message>(m_context->top())->m_id == (uint64_t)ins.cache.machine_num)); break; case MESSAGE_IS_PROTO: CHECK_STACK(1, 2); m_context->push(bvalue(ptr<Message>(m_context->top())->protocol_id() == (uint64_t)ins.cache.machine_num)); break; case MESSAGE_ID: { CHECK_STACK(1, 2); Message *msg = ptr<Message>(m_context->top()); m_context->push(value((long long)msg->m_id)); } break; case MESSAGE_SPLIT_ID: { CHECK_STACK(1, 3); Message *msg = ptr<Message>(m_context->top()); m_context->push(value((long long)msg->message_id())); m_context->push(value((long long)msg->protocol_id())); } break; case MESSAGE_CHECK: CHECK_STACK(1, 1); if (!is(m_context->top(), MESSAGE)) { m_context->pop(); m_context->push(False); } break; case MESSAGE_FORWARD: { CHECK_STACK(1, 1); long long id = ins.cache.machine_num; const Message &msg = *ptr<Message>(m_context->top()); Message *nmsg = new_message(id, msg.sysarg_count(), msg.arg_count() + 1); std::copy(msg.sysargs(), msg.sysargs_end(), nmsg->sysargs()); nmsg->args()[0] = value(new_string(msg.name())); std::copy(msg.args(), msg.args_end(), nmsg->args() + 1); m_context->pop(); m_context->push(value(nmsg)); break; } case MESSAGE_SYS_PREFIX: { long long count = ins.arg1.machine_num, counter = 0; CHECK_STACK(1 + count, 1); const Value *sdata = m_context->stack_pos() - 1 - count; const Message &msg = *ptr<Message>(*sdata++); Message *nmsg = new_message(msg.m_id, msg.sysarg_count() + count, msg.arg_count()); Message::iterator to = nmsg->sysargs(); while (counter++ < count) { *to++ = *sdata++; } std::copy(msg.sysargs(), msg.sysargs_end(), to); std::copy(msg.args(), msg.args_end(), nmsg->args()); while (--counter != 0) { m_context->pop(); } m_context->pop(); // message we read off stack before. m_context->push(value(nmsg)); break; } case MESSAGE_SYS_UNPACK: { long long count = ins.arg1.machine_num, pos = count - 1; CHECK_STACK(1, 1 + count); const Message *msg = ptr<Message>(m_context->top()); Message::const_iterator args = msg->sysargs(); long long len = (long long)msg->sysarg_count(); while (pos >= 0) { if (pos >= len) m_context->push(Undef); else m_context->push(args[pos]); pos -= 1; } } break; case MESSAGE_UNPACK: { long long first_count = ins.arg1.machine_num, first_counter = 0; long long splat = ins.arg2.machine_num; long long last_count = ins.arg3.machine_num, last_counter = 0; CHECK_STACK(1, 1 + first_count + last_count + (splat?1:0)); const Message *msg = ptr<Message>(m_context->top()); Message::const_iterator args = msg->args(); long long len = (long long)msg->arg_count(), pos = len - 1; while (last_counter < last_count && pos >= first_count) { if (pos >= len) m_context->push(Nil); else m_context->push(args[pos]); pos -= 1; last_counter += 1; } if (splat != 0) { if (pos >= first_count) { Tuple *splat_tuple = new_tuple(pos - first_count + 1); Tuple::iterator out = splat_tuple->end(); while (pos >= first_count) { --out; *out = args[pos]; pos -= 1; } m_context->push(value(splat_tuple)); } else { m_context->push(value(new_tuple(0))); } } pos = first_count - 1; while (first_counter < first_count && pos >= 0) { if (pos >= len) m_context->push(Nil); else m_context->push(args[pos]); pos -= 1; first_counter += 1; } } break; case STRING_COERCE: { const Value &coerce = ins.arg1; const Value &val = vstore(m_context->top()); if (is(val, STRING)) { CHECK_STACK(1, 2); // push a nil like we called the method. m_context->push(Nil); } else { CHECK_STACK(1, -1); m_context->pop(); channel_send(this, val, value(new_message(coerce)), value(m_context)); } } clear_vstore(); break; case STRING_NEW: { long long count = ins.arg1.machine_num, counter = 0; CHECK_STACK(count, 1); const Value *sp = m_context->stack_pos() - 1; size_t len = 0; while (count > 0 && counter < count) { assert(is(sp[-counter], STRING)); len += ptr<String>(sp[-counter])->length(); ++counter; } String *res = new_string(len); String::iterator out = res->begin(); counter = 0; while (count > 0 && counter < count) { const String *val = ptr<String>(m_context->top()); out = std::copy(val->begin(), val->end(), out); m_context->pop(); ++counter; } m_context->push(value(res)); } break; case TUPLE_NEW: { long long count = ins.arg1.machine_num, counter = 0; CHECK_STACK(count, 1); Tuple *tuple = new_tuple(count); Tuple::iterator out = tuple->begin(); while (count > 0 && counter < count) { *out++ = m_context->top(); m_context->pop(); ++counter; } m_context->push(value(tuple)); } break; case TUPLE_SPLAT: { CHECK_STACK(2, 1); const Tuple *tuple2 = ptr<Tuple>(m_context->top()); m_context->pop(); const Tuple *tuple1 = ptr<Tuple>(m_context->top()); m_context->pop(); Tuple *tuple = join_tuple(tuple1, tuple2); m_context->push(value(tuple)); } break; case TUPLE_UNPACK: { long long first_count = ins.arg1.machine_num, first_counter = 0; long long splat = ins.arg2.machine_num; long long last_count = ins.arg3.machine_num, last_counter = 0; CHECK_STACK(1, 1 + first_count + last_count + (splat?1:0)); const Tuple &tuple = *ptr<Tuple>(m_context->top()); long long len = tuple.size(), pos = tuple.size() - 1; while (last_counter < last_count && pos >= first_count) { if (pos >= len) m_context->push(Nil); else m_context->push(tuple[pos]); pos -= 1; last_counter += 1; } if (splat != 0) { if (pos >= first_count) { Tuple *splat_tuple = new_tuple(pos - first_count + 1); Tuple::iterator out = splat_tuple->end(); while (pos >= first_count) { --out; *out = tuple[pos]; pos -= 1; } m_context->push(value(splat_tuple)); } else { m_context->push(value(new_tuple(0))); } } pos = first_count - 1; while (first_counter < first_count && pos >= 0) { if (pos >= len) m_context->push(Nil); else m_context->push(tuple[pos]); pos -= 1; first_counter += 1; } } break; default: printf("Panic! Unknown instruction %d\n", ins.instruction); exit(1); } TRACE_OUT(TRACE_VM, TRACE_SPAM) { tprintf("Output: %d", (int)output); if ((long)output > 0) { const Value *it = std::max( m_context->stack_begin(), m_context->stack_pos() - output); for (; it != m_context->stack_pos(); it++) { tprintf("\n %s", inspect(*it).c_str()); } } tprintf(" <--\n"); tprintf("----------------\n"); }
int main(int argc, char *argv[]) { int errn; string *str; int complete = -1; int i; long ans; long logintimeout = 20; char *s; char *password; char *username; if(argc < 4) { fprintf(stderr, "Usage: %s user password connecstring\n", argv[0]); exit(1); } if((mes = new_message(0)) == NULL) { fprintf(stderr, "%s: Cannot open message queue\n", argv[0]); exit(1); } /* * I believe a fork duplicates malloced stuff, I am in the poo if it does not :-) */ errn = fork(); if(errn == -1) { fprintf(stderr, "%s: Cannot fork child process\n", argv[0]); exit(1); } else if(errn) { /* * This is the parent - which behaves like clien */ /* * Initially just a status message is snt back, zero string length * * Still needs a string to put it into */ str = new_string(); if(message_receive(mes, str, &complete, MES_SERVER_TO_CLIENT) < 0) { fprintf(stderr, "%s: %s\n", argv[0], string_s(str)); message_destroy(mes); message_delete(mes); string_delete(str); exit(1); } else { printf("%d\n",message_id(mes)) ; message_delete(mes); string_delete(str); exit(0); } } /* * All parents have exited now */ /* * This is all a child */ /* * I think I need to do this here... * I do not fully understand why, it just works! * otherwise shell parent hangs! */ setsid(); if(fork()) exit(0); close(0); close(1); close(2); /* * We are in daemon mode now */ /* * open the database */ str = new_string(); for(i=3;i<argc;i++) { string_cat(str, argv[i]); if(i < argc - 1) string_cat_c(str, ' '); } username = strdup(argv[1]); password = strdup(argv[2]); wipe(argv[2]); wipe(argv[1]); ans = SQLAllocHandle(SQL_HANDLE_ENV, SQL_NULL_HANDLE, &(env)); if((ans != SQL_SUCCESS) && (ans != SQL_SUCCESS_WITH_INFO)) { message_status(mes, 127, "ODBC: Cannot allocate environment handle\n", MES_SERVER_TO_CLIENT); message_delete(mes); free(username); free(password); exit(1); } ans = SQLSetEnvAttr(env, SQL_ATTR_ODBC_VERSION, (void*)SQL_OV_ODBC3, 0); if ((ans != SQL_SUCCESS) && (ans != SQL_SUCCESS_WITH_INFO)) { SQLFreeHandle(SQL_HANDLE_ENV, env); message_status(mes, 127, "ODBC: Cannot set environment handle attributes\n", MES_SERVER_TO_CLIENT); message_delete(mes); exit(1); } /* 2. allocate connection handle, set timeout */ ans = SQLAllocHandle(SQL_HANDLE_DBC, env, &(hdbc)); if ((ans != SQL_SUCCESS) && (ans != SQL_SUCCESS_WITH_INFO)) { SQLFreeHandle(SQL_HANDLE_ENV, env); message_status(mes, 127, "ODBC: Cannot allocate database handle\n", MES_SERVER_TO_CLIENT); message_delete(mes); free(username); free(password); exit(1); } /* * TODO - Parameterize ODBC_TIMEOUT as environment variable */ s = getenv("ODBC_TIMEOUT"); if(s != NULL) { if(*s) { logintimeout = atol(s); } } SQLSetConnectAttr(hdbc, SQL_LOGIN_TIMEOUT, (SQLPOINTER)logintimeout, 0); /* 3. Connect to the datasource */ ans = SQLConnect(hdbc, (SQLCHAR*) string_s(str), SQL_NTS, (SQLCHAR*) username, SQL_NTS, (SQLCHAR*) password, SQL_NTS); if ((ans != SQL_SUCCESS) && (ans != SQL_SUCCESS_WITH_INFO)) { message_status(mes, 127, "ODBC: Cannot connect to database\n", MES_SERVER_TO_CLIENT); message_delete(mes); /* SQLGetDiagRec(SQL_HANDLE_DBC, V_OD_hdbc,1, V_OD_stat, &V_OD_err,V_OD_msg,100,&V_OD_mlen); printf("%s (%d)\n",V_OD_msg,V_OD_err); */ SQLFreeHandle(SQL_HANDLE_DBC, hdbc); SQLFreeHandle(SQL_HANDLE_ENV, env); free(username); free(password); exit(1); } /* * Transmit to parent that we are hunky dory */ message_status(mes, 0, "", MES_SERVER_TO_CLIENT); /* * We are open for business - Lets go */ mainloop(); /* * At the end, tidy up */ SQLDisconnect(hdbc); SQLFreeHandle(SQL_HANDLE_DBC, hdbc); SQLFreeHandle(SQL_HANDLE_ENV, env); message_destroy(mes); message_delete(mes); free(username); free(password); exit(0); }
static void load_rss(cups_array_t *rss, /* I - RSS messages */ const char *filename) /* I - File to load */ { FILE *fp; /* File pointer */ char line[4096], /* Line from file */ *subject, /* Subject */ *text, /* Text */ *link_url, /* Link URL */ *start, /* Start of element */ *end; /* End of element */ time_t event_time; /* Event time */ int sequence_number; /* Sequence number */ int in_item; /* In an item */ _cups_rss_t *msg; /* New message */ if ((fp = fopen(filename, "r")) == NULL) { if (errno != ENOENT) fprintf(stderr, "ERROR: Unable to open %s: %s\n", filename, strerror(errno)); return; } subject = NULL; text = NULL; link_url = NULL; event_time = 0; sequence_number = 0; in_item = 0; while (fgets(line, sizeof(line), fp)) { if (strstr(line, "<item>")) in_item = 1; else if (strstr(line, "</item>") && in_item) { if (subject && text) { msg = new_message(sequence_number, subject, text, link_url, event_time); if (msg) cupsArrayAdd(rss, msg); } else { if (subject) free(subject); if (text) free(text); if (link_url) free(link_url); } subject = NULL; text = NULL; link_url = NULL; event_time = 0; sequence_number = 0; in_item = 0; } else if (!in_item) continue; else if ((start = strstr(line, "<title>")) != NULL) { start += 7; if ((end = strstr(start, "</title>")) != NULL) { *end = '\0'; subject = strdup(start); } } else if ((start = strstr(line, "<description>")) != NULL) { start += 13; if ((end = strstr(start, "</description>")) != NULL) { *end = '\0'; text = strdup(start); } } else if ((start = strstr(line, "<link>")) != NULL) { start += 6; if ((end = strstr(start, "</link>")) != NULL) { *end = '\0'; link_url = strdup(start); } } else if ((start = strstr(line, "<pubDate>")) != NULL) { start += 9; if ((end = strstr(start, "</pubDate>")) != NULL) { *end = '\0'; event_time = httpGetDateTime(start); } } else if ((start = strstr(line, "<guid>")) != NULL) sequence_number = atoi(start + 6); } if (subject) free(subject); if (text) free(text); if (link_url) free(link_url); fclose(fp); }
int main(int argc, char *argv[]) { int errn; string *str; int complete = -1; int i; if(argc < 2) { fprintf(stderr, "Usage: %s connecstring\n", argv[0]); exit(1); } if((mes = new_message(0)) == NULL) { fprintf(stderr, "%s: Cannot open message queue\n", argv[0]); exit(1); } /* * I believe a fork duplicates malloced stuff, I am in the poo if it does not :-) */ errn = fork(); if(errn == -1) { fprintf(stderr, "%s: Cannot fork child process\n", argv[0]); exit(1); } else if(errn) { /* * This is the parent - which behaves like clien */ /* * Initially just a status message is snt back, zero string length * * Still needs a string to put it into */ str = new_string(); if(message_receive(mes, str, &complete, MES_SERVER_TO_CLIENT) < 0) { fprintf(stderr, "%s: %s\n", argv[0], string_s(str)); message_destroy(mes); message_delete(mes); string_delete(str); exit(1); } else { printf("%d\n",message_id(mes)) ; message_delete(mes); string_delete(str); exit(0); } } /* * All parents have exited now */ /* * This is all a child */ /* * I think I need to do this here... * I do not fully understand why, it just works! * otherwise shell parent hangs! */ setsid(); if(fork()) exit(0); close(0); close(1); close(2); /* * We are in daemon mode now */ /* * open the database */ str = new_string(); for(i=1;i<argc;i++) { string_cat(str, argv[i]); if((!strncasecmp(argv[i], "password", 8)) || (!strncasecmp(argv[i], "user", 4)) || (!strncasecmp(argv[i], "useriname", 8))) wipe(argv[i]); if(i < argc - 1) string_cat_c(str, ' '); } sqldb = PQconnectdb(string_s(str)); string_delete(str); if(sqldb == NULL) { message_status(mes, 127, "Error allocating connection\n", MES_SERVER_TO_CLIENT); message_delete(mes); exit(1); } if (PQstatus(sqldb) != CONNECTION_OK) { char ws[64]; snprintf(ws, 63, "Error opening postgres %s/%s\n", PQhost(sqldb), PQdb(sqldb)); ws[63] = 0; message_status(mes, 127, ws, MES_SERVER_TO_CLIENT); PQfinish(sqldb); message_delete(mes); exit(1); } /* * Transmit to parent that we are hunky dory */ message_status(mes, 0, "", MES_SERVER_TO_CLIENT); /* * We are open for business - Lets go */ mainloop(); /* * At the end, tidy up */ PQfinish(sqldb); message_destroy(mes); message_delete(mes); exit(0); }
int /* O - Exit status */ main(int argc, /* I - Number of command-line arguments */ char *argv[]) /* I - Command-line arguments */ { int i; /* Looping var */ ipp_t *event; /* Event from scheduler */ ipp_state_t state; /* IPP event state */ char scheme[32], /* URI scheme ("rss") */ username[256], /* Username for remote RSS */ host[1024], /* Hostname for remote RSS */ resource[1024], /* RSS file */ *options; /* Options */ int port, /* Port number for remote RSS */ max_events; /* Maximum number of events */ http_t *http; /* Connection to remote server */ http_status_t status; /* HTTP GET/PUT status code */ char filename[1024], /* Local filename */ newname[1024]; /* filename.N */ cups_lang_t *language; /* Language information */ ipp_attribute_t *printer_up_time, /* Timestamp on event */ *notify_sequence_number,/* Sequence number */ *notify_printer_uri; /* Printer URI */ char *subject, /* Subject for notification message */ *text, /* Text for notification message */ link_url[1024], /* Link to printer */ link_scheme[32], /* Scheme for link */ link_username[256], /* Username for link */ link_host[1024], /* Host for link */ link_resource[1024]; /* Resource for link */ int link_port; /* Link port */ cups_array_t *rss; /* RSS message array */ _cups_rss_t *msg; /* RSS message */ char baseurl[1024]; /* Base URL */ fd_set input; /* Input set for select() */ struct timeval timeout; /* Timeout for select() */ int changed; /* Has the RSS data changed? */ int exit_status; /* Exit status */ fprintf(stderr, "DEBUG: argc=%d\n", argc); for (i = 0; i < argc; i ++) fprintf(stderr, "DEBUG: argv[%d]=\"%s\"\n", i, argv[i]); /* * See whether we are publishing this RSS feed locally or remotely... */ if (httpSeparateURI(HTTP_URI_CODING_ALL, argv[1], scheme, sizeof(scheme), username, sizeof(username), host, sizeof(host), &port, resource, sizeof(resource)) < HTTP_URI_OK) { fprintf(stderr, "ERROR: Bad RSS URI \"%s\"!\n", argv[1]); return (1); } max_events = 20; if ((options = strchr(resource, '?')) != NULL) { *options++ = '\0'; if (!strncmp(options, "max_events=", 11)) { max_events = atoi(options + 11); if (max_events <= 0) max_events = 20; } } rss = cupsArrayNew((cups_array_func_t)compare_rss, NULL); if (host[0]) { /* * Remote feed, see if we can get the current file... */ int fd; /* Temporary file */ if ((rss_password = strchr(username, ':')) != NULL) *rss_password++ = '\0'; cupsSetPasswordCB(password_cb); cupsSetUser(username); if ((fd = cupsTempFd(filename, sizeof(filename))) < 0) { fprintf(stderr, "ERROR: Unable to create temporary file: %s\n", strerror(errno)); return (1); } if ((http = httpConnect(host, port)) == NULL) { fprintf(stderr, "ERROR: Unable to connect to %s on port %d: %s\n", host, port, strerror(errno)); close(fd); unlink(filename); return (1); } status = cupsGetFd(http, resource, fd); close(fd); if (status != HTTP_OK && status != HTTP_NOT_FOUND) { fprintf(stderr, "ERROR: Unable to GET %s from %s on port %d: %d %s\n", resource, host, port, status, httpStatus(status)); httpClose(http); unlink(filename); return (1); } strlcpy(newname, filename, sizeof(newname)); httpAssembleURI(HTTP_URI_CODING_ALL, baseurl, sizeof(baseurl), "http", NULL, host, port, resource); } else { const char *cachedir, /* CUPS_CACHEDIR */ *server_name, /* SERVER_NAME */ *server_port; /* SERVER_PORT */ http = NULL; if ((cachedir = getenv("CUPS_CACHEDIR")) == NULL) cachedir = CUPS_CACHEDIR; if ((server_name = getenv("SERVER_NAME")) == NULL) server_name = "localhost"; if ((server_port = getenv("SERVER_PORT")) == NULL) server_port = "631"; snprintf(filename, sizeof(filename), "%s/rss%s", cachedir, resource); snprintf(newname, sizeof(newname), "%s.N", filename); httpAssembleURIf(HTTP_URI_CODING_ALL, baseurl, sizeof(baseurl), "http", NULL, server_name, atoi(server_port), "/rss%s", resource); } /* * Load the previous RSS file, if any... */ load_rss(rss, filename); changed = cupsArrayCount(rss) == 0; /* * Localize for the user's chosen language... */ language = cupsLangDefault(); /* * Read events and update the RSS file until we are out of events. */ for (exit_status = 0, event = NULL;;) { if (changed) { /* * Save the messages to the file again, uploading as needed... */ if (save_rss(rss, newname, baseurl)) { if (http) { /* * Upload the RSS file... */ if ((status = cupsPutFile(http, resource, filename)) != HTTP_CREATED) fprintf(stderr, "ERROR: Unable to PUT %s from %s on port %d: %d %s\n", resource, host, port, status, httpStatus(status)); } else { /* * Move the new RSS file over top the old one... */ if (rename(newname, filename)) fprintf(stderr, "ERROR: Unable to rename %s to %s: %s\n", newname, filename, strerror(errno)); } changed = 0; } } /* * Wait up to 30 seconds for an event... */ timeout.tv_sec = 30; timeout.tv_usec = 0; FD_ZERO(&input); FD_SET(0, &input); if (select(1, &input, NULL, NULL, &timeout) < 0) continue; else if (!FD_ISSET(0, &input)) { fprintf(stderr, "DEBUG: %s is bored, exiting...\n", argv[1]); break; } /* * Read the next event... */ event = ippNew(); while ((state = ippReadFile(0, event)) != IPP_DATA) { if (state <= IPP_IDLE) break; } if (state == IPP_ERROR) fputs("DEBUG: ippReadFile() returned IPP_ERROR!\n", stderr); if (state <= IPP_IDLE) break; /* * Collect the info from the event... */ printer_up_time = ippFindAttribute(event, "printer-up-time", IPP_TAG_INTEGER); notify_sequence_number = ippFindAttribute(event, "notify-sequence-number", IPP_TAG_INTEGER); notify_printer_uri = ippFindAttribute(event, "notify-printer-uri", IPP_TAG_URI); subject = cupsNotifySubject(language, event); text = cupsNotifyText(language, event); if (printer_up_time && notify_sequence_number && subject && text) { /* * Create a new RSS message... */ if (notify_printer_uri) { httpSeparateURI(HTTP_URI_CODING_ALL, notify_printer_uri->values[0].string.text, link_scheme, sizeof(link_scheme), link_username, sizeof(link_username), link_host, sizeof(link_host), &link_port, link_resource, sizeof(link_resource)); httpAssembleURI(HTTP_URI_CODING_ALL, link_url, sizeof(link_url), "http", link_username, link_host, link_port, link_resource); } msg = new_message(notify_sequence_number->values[0].integer, xml_escape(subject), xml_escape(text), notify_printer_uri ? xml_escape(link_url) : NULL, printer_up_time->values[0].integer); if (!msg) { fprintf(stderr, "ERROR: Unable to create message: %s\n", strerror(errno)); exit_status = 1; break; } /* * Add it to the array... */ cupsArrayAdd(rss, msg); changed = 1; /* * Trim the array as needed... */ while (cupsArrayCount(rss) > max_events) { msg = cupsArrayFirst(rss); cupsArrayRemove(rss, msg); delete_message(msg); } } if (subject) free(subject); if (text) free(text); ippDelete(event); event = NULL; } /* * We only get here when idle or error... */ ippDelete(event); if (http) { unlink(filename); httpClose(http); } return (exit_status); }
/* virtual */ void LLPluginProcessChild::receivePluginMessage(const std::string &message) { LL_DEBUGS("Plugin") << "Received from plugin: " << message << LL_ENDL; if(mBlockingRequest) { // LL_ERRS("Plugin") << "Can't send a message while already waiting on a blocking request -- aborting!" << LL_ENDL; } // Incoming message from the plugin instance bool passMessage = true; // FIXME: how should we handle queueing here? // Intercept certain base messages (responses to ones sent by this class) { // Decode this message LLPluginMessage parsed; parsed.parse(message); if(parsed.hasValue("blocking_request")) { mBlockingRequest = true; } std::string message_class = parsed.getClass(); if(message_class == "base") { std::string message_name = parsed.getName(); if(message_name == "init_response") { // The plugin has finished initializing. setState(STATE_RUNNING); // Don't pass this message up to the parent passMessage = false; LLPluginMessage new_message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin_response"); LLSD versions = parsed.getValueLLSD("versions"); new_message.setValueLLSD("versions", versions); if(parsed.hasValue("plugin_version")) { std::string plugin_version = parsed.getValue("plugin_version"); new_message.setValueLLSD("plugin_version", plugin_version); } // Let the parent know it's loaded and initialized. sendMessageToParent(new_message); } else if(message_name == "shm_remove_response") { // Don't pass this message up to the parent passMessage = false; std::string name = parsed.getValue("name"); sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name); if(iter != mSharedMemoryRegions.end()) { // detach the shared memory region iter->second->detach(); // and remove it from our map mSharedMemoryRegions.erase(iter); // Finally, send the response to the parent. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove_response"); message.setValue("name", name); sendMessageToParent(message); } else { LL_WARNS("Plugin") << "shm_remove_response for unknown memory segment!" << LL_ENDL; } } } else if (message_class == LLPLUGIN_MESSAGE_CLASS_INTERNAL) { bool flush = false; std::string message_name = parsed.getName(); if(message_name == "shutdown") { // The plugin is finished. setState(STATE_UNLOADING); flush = true; } else if (message_name == "flush") { flush = true; passMessage = false; } if (flush) { flushMessages(); } } } if(passMessage) { LL_DEBUGS("Plugin") << "Passing through to parent: " << message << LL_ENDL; writeMessageRaw(message); } while(mBlockingRequest) { // The plugin wants to block and wait for a response to this message. sleep(mSleepTime); // this will pump the message pipe and process messages if(mBlockingResponseReceived || mSocketError != APR_SUCCESS || (mMessagePipe == NULL)) { // Response has been received, or we've hit an error state. Stop waiting. mBlockingRequest = false; mBlockingResponseReceived = false; } } }
int main(int argc, char *argv[]) { int errn; string *str; int complete = -1; int i; char *sqlname[] = { "_dummy", "host", "user", "password", "dbname", "port", "socket", "flag" }; sqlarg *sarg; /* * Username and password may be in the connection string */ long flag = 0; unsigned int port = 0; MYSQL *tdb; if(argc < 2) { fprintf(stderr, "Usage: %s connecstring\n", argv[0]); exit(1); } if((mes = new_message(0)) == NULL) { fprintf(stderr, "%s: Cannot open message queue\n", argv[0]); exit(1); } /* * I believe a fork duplicates malloced stuff, I am in the poo if it does not :-) */ errn = fork(); if(errn == -1) { fprintf(stderr, "%s: Cannot fork child process\n", argv[0]); exit(1); } else if(errn) { /* * This is the parent - which behaves like clien */ /* * Initially just a status message is snt back, zero string length * * Still needs a string to put it into */ str = new_string(); if(message_receive(mes, str, &complete, MES_SERVER_TO_CLIENT) < 0) { fprintf(stderr, "%s: %s\n", argv[0], string_s(str)); message_destroy(mes); message_delete(mes); string_delete(str); exit(1); } else { printf("%d\n",message_id(mes)) ; message_delete(mes); string_delete(str); exit(0); } } /* * All parents have exited now */ /* * This is all a child */ /* * I think I need to do this here... * I do not fully understand why, it just works! * otherwise shell parent hangs! */ setsid(); if(fork()) exit(0); close(0); close(1); close(2); /* * We are in daemon mode now */ /* * open the database */ str = new_string(); for(i=1;i<argc;i++) { string_cat(str, argv[i]); if((!strncasecmp(argv[i], "password", 8)) || (!strncasecmp(argv[i], "user", 4)) || (!strncasecmp(argv[i], "username", 8))) wipe(argv[i]); if(i < argc - 1) string_cat_c(str, ' '); } sarg = new_sqlarg(sqlname, string_s(str), SMYSQL_PARAMETERS); string_delete(str); if(sarg == NULL) { message_status(mes, 127, "Error allocating string parameters\n", MES_SERVER_TO_CLIENT); message_delete(mes); exit(1); } if(sqlargi(sarg, SMYSQL_PORT) != NULL) port = atoi(sqlargi(sarg, SMYSQL_PORT)); if(sqlargi(sarg, SMYSQL_FLAG) != NULL) flag = atol(sqlargi(sarg, SMYSQL_FLAG)); sqldb = mysql_init(NULL); if(sqldb == NULL) { message_status(mes, 127, "Error allocating connection\n", MES_SERVER_TO_CLIENT); sqlarg_delete(sarg); message_delete(mes); exit(1); } tdb = mysql_real_connect(sqldb, sqlargi(sarg, SMYSQL_HOST), sqlargi(sarg, SMYSQL_USER), sqlargi(sarg, SMYSQL_PASSWORD), sqlargi(sarg, SMYSQL_DBNAME), port, sqlargi(sarg, SMYSQL_SOCKET), flag); sqlarg_delete(sarg); if(tdb == NULL) { char ws[128]; snprintf(ws, 127, "Error opening mysql: %s\n", mysql_error(sqldb)); ws[127] = 0; message_status(mes, 127, ws, MES_SERVER_TO_CLIENT); mysql_close(sqldb); message_delete(mes); exit(1); } /* * Transmit to parent that we are hunky dory */ message_status(mes, 0, "", MES_SERVER_TO_CLIENT); /* * We are open for business - Lets go */ mainloop(); /* * At the end, tidy up */ mysql_close(sqldb); message_destroy(mes); message_delete(mes); exit(0); }
/* virtual */ void LLPluginProcessChild::receivePluginMessage(const std::string &message) { LL_DEBUGS("Plugin") << "Received from plugin: " << message << LL_ENDL; // Incoming message from the plugin instance bool passMessage = true; // FIXME: how should we handle queueing here? // Intercept certain base messages (responses to ones sent by this class) { // Decode this message LLPluginMessage parsed; parsed.parse(message); std::string message_class = parsed.getClass(); if(message_class == "base") { std::string message_name = parsed.getName(); if(message_name == "init_response") { // The plugin has finished initializing. setState(STATE_RUNNING); // Don't pass this message up to the parent passMessage = false; LLPluginMessage new_message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "load_plugin_response"); LLSD versions = parsed.getValueLLSD("versions"); new_message.setValueLLSD("versions", versions); if(parsed.hasValue("plugin_version")) { std::string plugin_version = parsed.getValue("plugin_version"); new_message.setValueLLSD("plugin_version", plugin_version); } // Let the parent know it's loaded and initialized. sendMessageToParent(new_message); } else if(message_name == "shm_remove_response") { // Don't pass this message up to the parent passMessage = false; std::string name = parsed.getValue("name"); sharedMemoryRegionsType::iterator iter = mSharedMemoryRegions.find(name); if(iter != mSharedMemoryRegions.end()) { // detach the shared memory region iter->second->detach(); // and remove it from our map mSharedMemoryRegions.erase(iter); // Finally, send the response to the parent. LLPluginMessage message(LLPLUGIN_MESSAGE_CLASS_INTERNAL, "shm_remove_response"); message.setValue("name", name); sendMessageToParent(message); } else { LL_WARNS("Plugin") << "shm_remove_response for unknown memory segment!" << LL_ENDL; } } } } if(passMessage) { LL_DEBUGS("Plugin") << "Passing through to parent: " << message << LL_ENDL; writeMessageRaw(message); } }