Exemplo n.º 1
0
void _xcb_out_send_sync(xcb_connection_t *c)
{
    /* wait for other writing threads to get out of my way. */
    while(c->out.writing)
        pthread_cond_wait(&c->out.cond, &c->iolock);
    get_socket_back(c);
    send_sync(c);
}
Exemplo n.º 2
0
/*{{{  log_start -- begin logging, send output to 'file'*/
int log_start(FILE *file)
{
  if (do_save == 0 && file) {
    share_file = file;
    do_save = 1;
    send_sync();
    return (1);
  } else
    return (0);
}
Exemplo n.º 3
0
// somewhat counterintuitively, this returns NULL if everything's ok.
char * create_trigger(zhash_t * triggers,
                      char * rule_id, 
                      zctx_t * context,
                      triggerconfig_t * tconf) {
  void * trigger_pipe = zthread_fork(context, trigger, tconf);
  send_sync("ping", trigger_pipe);
  char * pipe_resp = zstr_recv(trigger_pipe);

  if(strcmp(pipe_resp, "pong") == 0) {
    zhash_insert(triggers, rule_id, trigger_pipe);
    free(pipe_resp);
    return NULL;
  } else {
    zclock_log("something went wrong creating a trigger: %s", pipe_resp);
    return pipe_resp;
  }
}
Exemplo n.º 4
0
void add_monitor(rulepackage_t * rpkg, zmsg_t * reply) {
  // unconditionally fork a monitor for each line
  // they'll die when they get a channel change
  int i;
  for(i=1; i<4; i++) { 
    monitorconfig_t * mconf = malloc(sizeof(monitorconfig_t));
    mconf->line_id = i;
    mconf->source_worker = rpkg->servicename;
    mconf->out_socket = rpkg->base_config->portwatcher_endpoint;
    mconf->channel = rpkg->channel;
    void * monitor_pipe = zthread_fork(rpkg->context, watch_port, (void*)mconf);
    send_sync("ping", monitor_pipe);
    recv_sync("pong", monitor_pipe);
    zsocket_destroy(rpkg->context, monitor_pipe);
  }
  zmsg_pushstr(reply, "ok");
}
Exemplo n.º 5
0
void generic_worker(void * cvoid, zctx_t * context, void * pipe) {
  workerconfig_t *config = (workerconfig_t*) cvoid;
  zhash_t * rules = zhash_new();

  child_handshake(pipe);
  zmsg_t *reply = NULL;
  void * rule_pipe = NULL;
  char * ninja = config->base_config->identity;
  char * channel = config->channel;

  char * servicename = malloc(strlen(ninja) +
                              strlen(channel) + 2);
  sprintf(servicename, "%s:%s", ninja,channel);

  // sqlite stuff
  int rc;
  char * tail = NULL;
  sqlite3 *db = init_db(servicename);
  sqlite3_stmt * insert_stmt;
  zclock_log("%s worker preparing rules...", servicename);
  sqlite3_prepare_v2(db, "insert into rules VALUES (@RULEID, @TRIGGER_NAME, @TARGET_WORKER, @AUTH, @ADDINS);", 512, &insert_stmt, NULL);
  zclock_log("%s worker reloading rules...", servicename);
  reload_rules(context, db, servicename, channel, rules);
  zclock_log("%s worker connecting...", servicename);
  mdwrk_t *session = mdwrk_new (config->base_config->broker_endpoint, servicename, 0);
  zclock_log("%s worker connected!", servicename);

  while (1) {
    zclock_log("%s worker waiting for work.", servicename);
    zmsg_t *request = mdwrk_recv (session, &reply);

    if (request == NULL)
      break;              //  Worker was interrupted

    char * command = zmsg_popstr(request);
    char * rule_id = zmsg_popstr(request);

    zclock_log("%s worker servicing request %s for rule %s", servicename,command,rule_id);
    reply = zmsg_new();
    if (strcmp(command, "AddTrigger") == 0) {
      zclock_log("new trigger!");
      if (zhash_lookup(rules, rule_id)) {
        // already have a rule with that id! WTF??
        // FIXME should probably delete this and reinstate
        zclock_log("Received duplicate rule %s, ignoring", rule_id);
        zmsg_destroy(&request);

        zmsg_pushstr(reply, "duplicate");
      } else {
        triggerconfig_t * tconf = malloc(sizeof(triggerconfig_t));
        create_triggerconfig(tconf, request, channel, rule_id);
        char * created = create_trigger(rules, rule_id, context, tconf);
        if(NULL == created) {
          // happy path, so add to db
          sqlite3_bind_text(insert_stmt, 1, tconf->rule_id, -1, SQLITE_TRANSIENT);
          sqlite3_bind_text(insert_stmt, 2, tconf->trigger_name, -1, SQLITE_TRANSIENT);
          sqlite3_bind_text(insert_stmt, 3, tconf->target_worker, -1, SQLITE_TRANSIENT);
          sqlite3_bind_text(insert_stmt, 4, tconf->auth, -1, SQLITE_TRANSIENT);
          sqlite3_bind_text(insert_stmt, 5, tconf->addins, -1, SQLITE_TRANSIENT);
          sqlite3_step(insert_stmt);
          sqlite3_clear_bindings(insert_stmt);
          sqlite3_reset(insert_stmt);

          zmsg_pushstr(reply, "ok");
        } else {
          zclock_log("create_trigger failed: %s", created);
          zmsg_pushstr(reply, created);
        }
        free(created);

      }
    } else if (strcmp(command,"RemoveRule") == 0) {

      if (rule_pipe=zhash_lookup(rules, rule_id)) {
        // found it
        zclock_log("rule %s exists, removing.", rule_id);
        send_sync("Destroy",rule_pipe);
        zclock_log("rule %s waiting for OK from pipe", rule_id);
        recv_sync("ok", rule_pipe);
        zsocket_destroy(context, rule_pipe);
        zhash_delete(rules, rule_id);
        zmsg_pushstr(reply, "ok");
        zclock_log("rule %s completely destroyed", rule_id);
      } else {
        // not there!
        zclock_log("Received delete trigger request for nonexistent rule %s, ignoring", rule_id);
        zmsg_pushstr(reply, "rule not found");
      }
    } else if (strcmp(command, "AddMonitor")==0) {
      // unconditionally fork a monitor for each line
      // they'll die when they get a channel change
      int i;
      for(i=1; i<4; i++) { 
        monitorconfig_t * mconf = malloc(sizeof(monitorconfig_t));
        mconf->line_id = i;
        mconf->source_worker = servicename;
        mconf->out_socket = config->base_config->portwatcher_endpoint;
        mconf->channel = channel;
        void * monitor_pipe = zthread_fork(context, watch_port, (void*)mconf);
        send_sync("ping", monitor_pipe);
        recv_sync("pong", monitor_pipe);
        zsocket_destroy(context, monitor_pipe);
      }
      zmsg_pushstr(reply, "ok");
    } else {
      zclock_log("Can't handle command %s: ignoring", command);
    }
    zmsg_destroy(&request);
  }
  mdwrk_destroy (&session);
  return;
}
Exemplo n.º 6
0
static int
set_new_event( int t )
{
    int ptr;
    unsigned char *data;
    int count;
    int follower;
    __GETMDX;

    data = mdx->data;
    ptr = mdx->track[t].current_mml_ptr;
    count = 0;
    follower = 0;

#if 0
    if ( ptr+1 <= mdx->length && t>7 ) {
        fprintf(stderr,"%2d %2x %2x\n",t,data[ptr],data[ptr+1]);
        fflush(stderr);
    }
#endif

    if ( data[ptr] <= MDX_MAX_REST ) {  /* rest */
        note_off(t);
        count = data[ptr]+1;
        mdx->track[t].gate = count+1;
        follower=0;

    } else if ( data[ptr] <= MDX_MAX_NOTE ) { /* note */
        note_on( t, data[ptr]);
        count = data[ptr+1]+1;
        do_quantize( t, count );
        follower = 1;

    } else {
        switch ( data[ptr] ) {

        case MDX_SET_TEMPO:
            set_tempo( data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_OPM_REG:
            set_opm_reg( t, data[ptr+1], data[ptr+2] );
            follower = 2;
            break;

        case MDX_SET_VOICE:
            set_voice( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_PHASE:
            set_phase( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_VOLUME:
            set_volume( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_VOLUME_DEC:
            dec_volume( t );
            follower = 0;
            break;

        case MDX_VOLUME_INC:
            inc_volume( t );
            follower = 0;
            break;

        case MDX_SET_QUANTIZE:
            set_quantize( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_KEYOFF:
            set_keyoff( t );
            follower = 0;
            break;

        case MDX_REPEAT_START:
            mdx->track[t].loop_counter[mdx->track[t].loop_depth] = data[ptr+1];
            if ( mdx->track[t].loop_depth < MDX_MAX_LOOP_DEPTH )
                mdx->track[t].loop_depth++;
            follower = 2;
            break;

        case MDX_REPEAT_END:
            if (--mdx->track[t].loop_counter[mdx->track[t].loop_depth-1] == 0 ) {
                if ( --mdx->track[t].loop_depth < 0 ) mdx->track[t].loop_depth=0;
            } else {
                if ( data[ptr+1] >= 0x80 ) {
                    ptr = ptr+2 - (0x10000-(data[ptr+1]*256 + data[ptr+2])) - 2;
                } else {
                    ptr = ptr+2 + data[ptr+1]*256 + data[ptr+2] - 2;
                }
            }
            follower = 2;
            break;

        case MDX_REPEAT_BREAK:
            if ( mdx->track[t].loop_counter[mdx->track[t].loop_depth-1] == 1 ) {
                if ( --mdx->track[t].loop_depth < 0 ) mdx->track[t].loop_depth=0;
                ptr = ptr+2 + data[ptr+1]*256 + data[ptr+2] -2 +2;
            }
            follower = 2;
            break;

        case MDX_SET_DETUNE:
            set_detune( t, data[ptr+1], data[ptr+2] );
            follower = 2;
            break;

        case MDX_SET_PORTAMENT:
            set_portament( t, data[ptr+1], data[ptr+2] );
            follower = 2;
            break;

        case MDX_DATA_END:
            if ( data[ptr+1] == 0x00 ) {
                count = -1;
                note_off(t);
                follower = 1;
            } else {
                ptr = ptr+2 - (0x10000-(data[ptr+1]*256 + data[ptr+2])) - 2;
                mdx->track[t].infinite_loop_times++;
                follower = 2;
            }
            break;

        case MDX_KEY_ON_DELAY:
            follower = 1;
            break;

        case MDX_SEND_SYNC:
            send_sync( data[ptr+1] );
            follower = 1;
            break;

        case MDX_RECV_SYNC:
            recv_sync( t );
            follower = 0;
            count = 1;
            break;

        case MDX_SET_FREQ:
            set_freq( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_PLFO:
            if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
                set_plfo_onoff( t, data[ptr+1]-0x80 );
                follower = 1;
            } else {
                set_plfo( t,
                          data[ptr+1], data[ptr+2], data[ptr+3],
                          data[ptr+4], data[ptr+5] );
                follower = 5;
            }
            break;

        case MDX_SET_ALFO:
            if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
                set_alfo_onoff( t, data[ptr+1]-0x80 );
                follower = 1;
            } else {
                set_alfo( t,
                          data[ptr+1], data[ptr+2], data[ptr+3],
                          data[ptr+4], data[ptr+5] );
                follower = 5;
            }
            break;

        case MDX_SET_OPMLFO:
            if ( data[ptr+1] == 0x80 || data[ptr+1] == 0x81 ) {
                set_hlfo_onoff( t, data[ptr+1]-0x80 );
                follower = 1;
            } else {
                set_hlfo( t,
                          data[ptr+1], data[ptr+2], data[ptr+3],
                          data[ptr+4], data[ptr+5] );
                follower = 5;
            }
            break;

        case MDX_SET_LFO_DELAY:
            set_lfo_delay( t, data[ptr+1] );
            follower = 1;
            break;

        case MDX_SET_PCM8_MODE:
            follower = 0;
            break;

        case MDX_FADE_OUT:
            if ( data[ptr+1]==0x00 ) {
                follower = 1;
                set_fade_out( 5 );
            } else {
                follower = 2;
                set_fade_out( data[ptr+2] );
            }
            break;

        default:
            count = -1;
            break;
        }
    }

    ptr += 1+follower;
    mdx->track[t].current_mml_ptr = ptr;

    return count;
}
Exemplo n.º 7
0
uint32_t uIPMain(void)
{
    uint32_t i;
    uip_ipaddr_t ipaddr;
    struct timer periodic_timer, arp_timer, can_sync_timer;

    LED_On(2);

    // Sys timer init 1/100 sec tick
    clock_init(2);

    timer_set(&periodic_timer, CLOCK_SECOND / 10);
    timer_set(&arp_timer, CLOCK_SECOND * 10);
    timer_set(&can_sync_timer, CLOCK_SECOND / 8); //ca. 1x pro sec wird gesynced

    // Initialize the ethernet device driver
    // Init MAC
    // Phy network negotiation
    tapdev_init(); //code in: ENET_TxDscrInit (ethernet.c) & ENET_RxDscrInit (ethernet.c) &  ETH_Start (stm32_eth.c)

    // Initialize the uIP TCP/IP stack.
    uip_init(); //code in uip.c

    // Init Server
    #ifdef TEST_GATEWAY
        uip_ipaddr(ipaddr, 10,0,241,2);
    #else
        uip_ipaddr(ipaddr, 10,0,241,1);
    #endif
    uip_sethostaddr(ipaddr); //ip
    uip_ipaddr(ipaddr, 10,0,240,0);
    uip_setdraddr(ipaddr);  //gw
    uip_ipaddr(ipaddr, 255,255,252,0);
    uip_setnetmask(ipaddr); //nm

    // Initialize the server listen on port 23
    uip_listen(HTONS(23));

    //turn led off, we are now ready for inncoming conenctions
    LED_Off(1);

    CanRxMsg RxMessage;
    int can_last_msg_id = 0;
    uint32_t nCount;

    while(1)
    {
        if(timer_expired(&can_sync_timer))
        {
            nCount++;
            timer_reset(&can_sync_timer);
            #ifndef TEST_GATEWAY
            send_sync( nCount % 2 );
            if( nCount % 2 == 1 )
                LED_On(2);
            else
                LED_Off(2);
            #endif
        }

        // ethernet stuff
        uip_len = tapdev_read(uip_buf);
        if(uip_len > 0) //read input
        {
            if(BUF->type == htons(UIP_ETHTYPE_IP)) //Layer3?
            {
                uip_arp_ipin();
                uip_input();
                /* If the above function invocation resulted in data that
                 should be sent out on the network, the global variable
                 uip_len is set to a value > 0. */
                if(uip_len > 0)
                {
                    uip_arp_out(); //get ARP of destination - or default gw (uip_arp.c)
                    tapdev_send(uip_buf,uip_len);
                }
            }
            else if(BUF->type == htons(UIP_ETHTYPE_ARP)) //Layer2?
            {
                uip_arp_arpin();
                /* If the above function invocation resulted in data that
                should be sent out on the network, the global variable
                uip_len is set to a value > 0. */
                if(uip_len > 0)
                {
                    tapdev_send(uip_buf,uip_len);
                }
            }
        }
        else if(timer_expired(&periodic_timer)) //check if there is data in the send queue of each connection and send it
        {
            timer_reset(&periodic_timer);
            for(i = 0; i < UIP_CONNS; i++)
            {
                uip_periodic(i); //sets uip_conn to the current connections (macro uip.h)
                /* If the above function invocation resulted in data that
                should be sent out on the network, the global variable
                uip_len is set to a value > 0. */
                if(uip_len > 0)
                {
                    uip_arp_out(); //get ARP of destination - or default gw (uip_arp.c)
                    tapdev_send(uip_buf,uip_len);
                }
            }
            #if UIP_UDP
            for(i = 0; i < UIP_UDP_CONNS; i++)
            {
                uip_udp_periodic(i);
                /* If the above function invocation resulted in data that
                should be sent out on the network, the global variable
                uip_len is set to a value > 0. */
                if(uip_len > 0)
                {
                    uip_arp_out(); //get ARP of destination - or default gw (uip_arp.c)
                    tapdev_send();
                }
            }
            #endif /* UIP_UDP */

            /* Call the ARP timer function every 10 seconds. */
            /* It updates the arp-table (removes old entries) */
            if(timer_expired(&arp_timer))
            {
                timer_reset(&arp_timer);
                uip_arp_timer();
            }
        }
    }
    return(TRUE);
}
Exemplo n.º 8
0
/**
 * returns the status of the execution
 *  0 = normal end
 *  1 = expect mismatch
 */
int execute_script(int sockfd, registry_t *script) {

	// current "pc" pointer to script line
	int curpos = 0;	
	line_t *line = NULL;
	int lineno = 0;

	int err = 0;
	ssize_t size = 0;
	line_t *errmsg = NULL;
	scriptlet_t *scr = NULL;

	while ( (err == 0) && (line = reg_get(script, curpos)) != NULL) {

		lineno = line->num;

		switch (line->cmd) {
		case CMD_COMMENT:
			if (!trace) {
				break;
			}
			// fall-through
		case CMD_MESSAGE:
			log_info("> %s\n", line->buffer);
			break;
		case CMD_ERRMSG:
			errmsg = line;
			break;
		case CMD_SEND:
			for (int i = 0; (scr = reg_get(&line->scriptlets, i)) != NULL; i++) {
				if (scr->exec != NULL) {
					scr->exec(line, scr);
				}
			}
			if (trace) {
				log_hexdump2(line->buffer, line->length, 0, "Send  : ");
			}

			size = write(sockfd, line->buffer, line->length);
			if (size < 0) {
				log_errno("Error writing to socket at line %d\n", lineno);
				err = -1;
			}
			break;
		case CMD_EXPECT:
			line->mask = mem_alloc_c(line->length, "line_mask");
			memset(line->mask, 0xff, line->length);
			for (int i = 0; (scr = reg_get(&line->scriptlets, i)) != NULL; i++) {
				if (scr->exec != NULL) {
					scr->exec(line, scr);
				}
			}
			err = compare_packet(sockfd, line->buffer, line->mask, line->length, lineno);
			mem_free(line->mask);
			line->mask = NULL;

			if (err != 0) {
				if (errmsg != NULL) {
					log_error("> %d: %s -> %d\n", lineno, errmsg->buffer, err);
				}
				return err;
			}
			break;
		case CMD_INIT:
			send_sync(sockfd);
			err = compare_packet(sockfd, line->buffer, NULL, line->length, lineno);
			if (err != 0) {
				if (errmsg != NULL) {
					log_error("> %d: %s -> %d\n", lineno, errmsg->buffer, err);
				}
				return err;
			}
			break;
		}
		curpos++;
	}

	return 0;
}
Exemplo n.º 9
0
void trigger(void *cvoid, 
             zctx_t * context, 
             void * control) {
  triggerconfig_t * c = (triggerconfig_t*) cvoid;
  //set up msgpack stuff
  zclock_log("watch_port started!");
  msgpack_zone mempool;
  msgpack_zone_init(&mempool, 2048);

  // TODO
  char * user_id = "17"; 
  // TODO get broker in somehow
  char * broker = "tcp://au.ninjablocks.com:5773";

  mdcli_t * client = mdcli_new(broker, 1); //VERBOSE

  triggermemory_t trigger_memory;
  msgpack_object * addins_obj = parse_msgpack(&mempool, c->addins);

  if(!parse_addins(addins_obj, &trigger_memory)) {
    //bad message
    zclock_log("bad trigger definition");
    msgpack_object_print(stdout, *addins_obj);
    send_sync("bad trigger", control);
    return;
  }
  zclock_log("Creating trigger: target %s, rule_id %s, name %s", 
             c->target_worker, c->rule_id, c->trigger_name);
  dump_trigger(&trigger_memory);
  triggerfunction trigger_func;
  if(!(trigger_func = find_trigger(c->channel, c->trigger_name))) {

    zclock_log("no trigger found for channel %s, trigger %s",
               c->channel, c->trigger_name);
    send_sync("no such trigger", control);
    return;
  }

  void * line = zsocket_new(context, ZMQ_SUB);


  // what line are we on?
  // this comes in the addins. 
  char * linesocket = to_linesocket(trigger_memory.line_id);
  zclock_log("trigger is connecting to listen on %s", linesocket);
  zsocket_connect(line, linesocket);

  zsockopt_set_unsubscribe(line, "");
  zsockopt_set_subscribe(line, "VALUE");
  recv_sync("ping", control);
  send_sync("pong", control);
  
  zmq_pollitem_t items [] = {
    { line, 0, ZMQ_POLLIN, 0 },
    { control, 0, ZMQ_POLLIN, 0 }
  };
  while(1) {
    // listen on control and line
    zmq_poll (items, 2, -1);
    if (items[1].revents & ZMQ_POLLIN) {
      zclock_log("rule %s received message on control pipe", c->rule_id);
      // control message
      // really only expecting DESTROY
      zmsg_t * msg = zmsg_recv(control);
      char * str = zmsg_popstr(msg);
      zmsg_destroy(&msg);
      
      if (strcmp("Destroy", str) == 0) {
        zclock_log("rule %s will quit on request", c->rule_id);
        free(str);
        send_sync("ok", control);
        zclock_log("rule %s quitting on request", c->rule_id);
        break;
      } else  {
        zclock_log("unexpected command %s for rule %s", str, c->rule_id);
        free(str);
        send_sync("ok", control);
      }
    }

    if (items[0].revents & ZMQ_POLLIN) {
      // serial update
      zmsg_t * msg = zmsg_recv(line);
      zframe_t * cmd = zmsg_pop(msg);
      if(zframe_streq(cmd, "CHANNEL_CHANGE")) {
        // TODO
        // must have been dormant to have gotten this
        char * new_channel = zmsg_popstr(msg);

        if(strcmp(c->channel, new_channel) == 0) {
        // oh, happy day! We're relevant again.
        // reactivate and start looking at reset levels.
          zclock_log("line %d: changed channel from %s to %s: trigger coming back to life", trigger_memory.line_id, c->channel, new_channel);
          zsockopt_set_subscribe(line, "VALUE");
          zsockopt_set_unsubscribe(line, "CHANNEL_CHANGE");
        }
        free(new_channel);
      } else if (zframe_streq(cmd, "VALUE")) {
        zframe_t * vframe = zmsg_pop(msg);
        int value;
        memcpy(&value, zframe_data(vframe), sizeof(int));
        char * update_channel = zmsg_popstr(msg);

        if(strcmp(c->channel, update_channel) != 0) {
          // channel changed,  go dormant
          // this is legit according to my tests at
          // https://gist.github.com/2042350

          zclock_log("line %d: changed channel from %s to %s: trigger going dormant", trigger_memory.line_id, c->channel, update_channel);
          zsockopt_set_subscribe(line, "CHANNEL_CHANGE");
          zsockopt_set_unsubscribe(line, "VALUE");
        } 
        
        else if(trigger_func(&trigger_memory, value)) {
          send_trigger(client, c->target_worker, c->rule_id, value, user_id);
        }           

        free(update_channel);
      } else {
        // shouldn't ever happen.
        zclock_log("shouldn't have received command %s\n", zframe_strdup(cmd));
      }
      zmsg_destroy(&msg);
      zframe_destroy(&cmd);
    }
    
  }

  msgpack_zone_destroy(&mempool);
}
Exemplo n.º 10
0
unsigned int xcb_send_request(xcb_connection_t *c, int flags, struct iovec *vector, const xcb_protocol_request_t *req)
{
    uint64_t request;
    uint32_t prefix[2];
    int veclen = req->count;
    enum workarounds workaround = WORKAROUND_NONE;

    if(c->has_error)
        return 0;

    assert(c != 0);
    assert(vector != 0);
    assert(req->count > 0);

    if(!(flags & XCB_REQUEST_RAW))
    {
        static const char pad[3];
        unsigned int i;
        uint16_t shortlen = 0;
        size_t longlen = 0;
        assert(vector[0].iov_len >= 4);
        /* set the major opcode, and the minor opcode for extensions */
        if(req->ext)
        {
            const xcb_query_extension_reply_t *extension = xcb_get_extension_data(c, req->ext);
            if(!(extension && extension->present))
            {
                _xcb_conn_shutdown(c, XCB_CONN_CLOSED_EXT_NOTSUPPORTED);
                return 0;
            }
            ((uint8_t *) vector[0].iov_base)[0] = extension->major_opcode;
            ((uint8_t *) vector[0].iov_base)[1] = req->opcode;
        }
        else
            ((uint8_t *) vector[0].iov_base)[0] = req->opcode;

        /* put together the length field, possibly using BIGREQUESTS */
        for(i = 0; i < req->count; ++i)
        {
            longlen += vector[i].iov_len;
            if(!vector[i].iov_base)
            {
                vector[i].iov_base = (char *) pad;
                assert(vector[i].iov_len <= sizeof(pad));
            }
        }
        assert((longlen & 3) == 0);
        longlen >>= 2;

        if(longlen <= c->setup->maximum_request_length)
        {
            /* we don't need BIGREQUESTS. */
            shortlen = longlen;
            longlen = 0;
        }
        else if(longlen > xcb_get_maximum_request_length(c))
        {
            _xcb_conn_shutdown(c, XCB_CONN_CLOSED_REQ_LEN_EXCEED);
            return 0; /* server can't take this; maybe need BIGREQUESTS? */
        }

        /* set the length field. */
        ((uint16_t *) vector[0].iov_base)[1] = shortlen;
        if(!shortlen)
        {
            prefix[0] = ((uint32_t *) vector[0].iov_base)[0];
            prefix[1] = ++longlen;
            vector[0].iov_base = (uint32_t *) vector[0].iov_base + 1;
            vector[0].iov_len -= sizeof(uint32_t);
            --vector, ++veclen;
            vector[0].iov_base = prefix;
            vector[0].iov_len = sizeof(prefix);
        }
    }
    flags &= ~XCB_REQUEST_RAW;

    /* do we need to work around the X server bug described in glx.xml? */
    /* XXX: GetFBConfigs won't use BIG-REQUESTS in any sane
     * configuration, but that should be handled here anyway. */
    if(req->ext && !req->isvoid && !strcmp(req->ext->name, "GLX") &&
            ((req->opcode == 17 && ((uint32_t *) vector[0].iov_base)[1] == 0x10004) ||
             req->opcode == 21))
        workaround = WORKAROUND_GLX_GET_FB_CONFIGS_BUG;

    /* get a sequence number and arrange for delivery. */
    pthread_mutex_lock(&c->iolock);
    /* wait for other writing threads to get out of my way. */
    while(c->out.writing)
        pthread_cond_wait(&c->out.cond, &c->iolock);
    get_socket_back(c);

    /* send GetInputFocus (sync_req) when 64k-2 requests have been sent without
     * a reply. */
    if(req->isvoid && c->out.request == c->in.request_expected + (1 << 16) - 2)
        send_sync(c);
    /* Also send sync_req (could use NoOp) at 32-bit wrap to avoid having
     * applications see sequence 0 as that is used to indicate
     * an error in sending the request */
    if((unsigned int) (c->out.request + 1) == 0)
        send_sync(c);

    /* The above send_sync calls could drop the I/O lock, but this
     * thread will still exclude any other thread that tries to write,
     * so the sequence number postconditions still hold. */
    send_request(c, req->isvoid, workaround, flags, vector, veclen);
    request = c->has_error ? 0 : c->out.request;
    pthread_mutex_unlock(&c->iolock);
    return request;
}
Exemplo n.º 11
0
int main(int argc, char *argv[]) {

	int rv = -1;

	const char *device = NULL;
	const char *tsocket = NULL;
	const char *scriptname = NULL;

	// wait for socket if not there right away?
	int dowait = 0;

	terminal_init();


        int i=1;
        while(i<argc && argv[i][0]=='-' && argv[i][1] != 0) {
          	switch(argv[i][1]) {
            	case '?':
                	assert_single_char(argv[i]);
                	usage(EXIT_SUCCESS);    /* usage() exits already */
                	break;
            	case 'd':
                	assert_single_char(argv[i]);
                	if (i < argc-1) {
                  		i++;
                  		device = argv[i];
                  		log_info("main: device = %s\n", device);
                	} else {
                  		log_error("-d requires <device> parameter\n");
                  		exit(1);
                	}
                	break;
            	case 'T':
                	assert_single_char(argv[i]);
                	if (i < argc-1) {
                  		i++;
                  		tsocket = argv[i];
                  		log_info("main: tools socket = %s\n", tsocket);
                	} else {
                  		log_error("-T requires <socket> parameter\n");
                  		exit(1);
                	}
                	break;
		case 'v':
			set_verbose(1);
			break;
		case 't':
			trace = 1;
			break;
		case 'w':
			dowait = 1;
			break;
            	default:
                	log_error("Unknown command line option %s\n", argv[i]);
                	usage(1);
                	break;
          	}
          	i++;
        }

	// next parameter is the script name
	if (i >= argc) {
		log_error("Script name parameter missing!\n");
		return -1;
	}

	scriptname = argv[i];
	i++;

	registry_t *script = load_script_from_file(scriptname);

	if (script != NULL) {

		int sockfd = socket_open(device, dowait);

		int toolsfd = -1;
		if (tsocket) {
			toolsfd = socket_open(tsocket, 1);

			send_sync(toolsfd);
		}
	
		if (sockfd >= 0) {

			rv = execute_script(sockfd, toolsfd, script);

			close(sockfd);
		}
		if (toolsfd >= 0) {
			close(toolsfd);
		}
	}

	return rv;
}
Exemplo n.º 12
0
/**
 * returns the status of the execution
 *  0 = normal end
 *  1 = expect mismatch
 */
int execute_script(int sockfd, int toolsfd, registry_t *script) {

	// current "pc" pointer to script line
	int curpos = 0;	
	line_t *line = NULL;
	int lineno = 0;

	int err = 0;
	ssize_t size = 0;
	line_t *errmsg = NULL;
	scriptlet_t *scr = NULL;

	// guaranteed to be valid; toolsfd may be not set (<0)
	int curfd = sockfd;

	while ( (err == 0) && (line = reg_get(script, curpos)) != NULL) {

		lineno = line->num;

		switch (line->cmd) {
		case CMD_COMMENT:
			if (!trace) {
				break;
			}
			// fall-through
		case CMD_MESSAGE:
			log_info("> %s\n", line->buffer);
			break;
		case CMD_ERRMSG:
			errmsg = line;
			break;
		case CMD_SEND:
			for (int i = 0; (scr = reg_get(&line->scriptlets, i)) != NULL; i++) {
				if (scr->exec != NULL) {
					scr->exec(line, scr);
				}
			}
			if (trace) {
				log_hexdump2(line->buffer, line->length, 0, "Send  : ");
			}

			size = write(curfd, line->buffer, line->length);
			if (size < 0) {
				log_errno("Error writing to socket at line %d\n", lineno);
				err = -1;
			}
			break;
		case CMD_EXPECT:
			line->mask = mem_alloc_c(line->length, "line_mask");
			memset(line->mask, 0xff, line->length);
			for (int i = 0; (scr = reg_get(&line->scriptlets, i)) != NULL; i++) {
				if (scr->exec != NULL) {
					scr->exec(line, scr);
				}
			}
			err = compare_packet(curfd, line->buffer, line->mask, line->length, lineno);
			mem_free(line->mask);
			line->mask = NULL;

			if (err != 0) {
				if (errmsg != NULL) {
					log_error("> %d: %s -> %d\n", lineno, errmsg->buffer, err);
				}
				return 1;
			}
			break;
		case CMD_INIT:
			send_sync(curfd);
			err = compare_packet(curfd, line->buffer, NULL, line->length, lineno);
			if (err != 0) {
				if (errmsg != NULL) {
					log_error("> %d: %s -> %d\n", lineno, errmsg->buffer, err);
				}
				return 1;
			}
			break;
		case CMD_CHANNEL:
			if ((!strcmp("tools", line->buffer)) && toolsfd >= 0) {
				curfd = toolsfd;
			} else
			if ((!strcmp("device", line->buffer)) && sockfd >= 0) {
				curfd = sockfd;
			} else {
				log_error("> %d: -> unknown channel name %s\n", lineno, line->buffer);
				return 1;
			}
			break;
		}
		curpos++;
	}

	return 0;
}
Exemplo n.º 13
0
void
send_belfox(char *msg)
{

  uint8_t repeat=BELFOX_REPEAT;
  uint8_t len=strnlen(msg,BELFOX_LEN+2)-1;
  
  // assert if length incorrect
  if (len != BELFOX_LEN) return;
  
  LED_ON();

#if defined (HAS_IRRX) || defined (HAS_IRTX) // Block IR_Reception
  cli();
#endif

#ifdef USE_RF_MODE
  change_RF_mode(RF_mode_slow);
#else

#ifdef HAS_MORITZ
  uint8_t restore_moritz = 0;
  if(moritz_on) {
    restore_moritz = 1;
    moritz_on = 0;
    set_txreport("21");
  }
#endif

  if(!cc_on)
    set_ccon();
#endif
  ccTX();                                       // Enable TX 
  do {
    send_sync();                                // sync

    for(int i = 1; i <= BELFOX_LEN; i++)        // loop input, for example 'L111001100110'
      send_bit(msg[i] == '1');

    CC1100_OUT_PORT &= ~_BV(CC1100_OUT_PIN);    // final low to complete last bit
        
    my_delay_ms(BELFOX_PAUSE);                  // pause

  } while(--repeat > 0);

  if(TX_REPORT) {                               // Enable RX
    ccRX();
  } else {
    ccStrobe(CC1100_SIDLE);
  }

#if defined (HAS_IRRX) || defined (HAS_IRTX) // Activate IR_Reception
  sei(); 
#endif

#ifdef USE_RF_MODE
  restore_RF_mode();
#else
#ifdef HAS_MORITZ
  if(restore_moritz)
    rf_moritz_init();
#endif
#endif
  LED_OFF();
}
Exemplo n.º 14
0
void parent_handshake(void*pipe) {
  send_sync("ping", pipe);
  recv_sync("pong", pipe);
}
Exemplo n.º 15
0
void child_handshake(void*pipe) {
  recv_sync("ping", pipe);
  send_sync("pong", pipe);
}