static int
doRunInstance(		struct nc_state_t *nc,
			ncMetadata *meta,
			char *instanceId,
			char *reservationId,
			virtualMachine *params, 
			char *imageId, char *imageURL, 
			char *kernelId, char *kernelURL, 
			char *ramdiskId, char *ramdiskURL, 
			char *keyName, 
			//			char *privMac, char *privIp, int vlan, 
			netConfig *netparams,
			char *userData, char *launchIndex,
			char **groupNames, int groupNamesSize,
			ncInstance **outInst)
{
    ncInstance * instance = NULL;
    * outInst = NULL;
    pid_t pid;
    netConfig ncnet;
    int error;

    memcpy(&ncnet, netparams, sizeof(netConfig));

    /* check as much as possible before forking off and returning */
    sem_p (inst_sem);
    instance = find_instance (&global_instances, instanceId);
    sem_v (inst_sem);
    if (instance) {
        logprintfl (EUCAFATAL, "Error: instance %s already running\n", instanceId);
        return 1; /* TODO: return meaningful error codes? */
    }
    if (!(instance = allocate_instance (instanceId, 
                                        reservationId,
                                        params, 
                                        imageId, imageURL,
                                        kernelId, kernelURL,
                                        ramdiskId, ramdiskURL,
                                        instance_state_names[PENDING], 
                                        PENDING, 
                                        meta->userId, 
                                        &ncnet, keyName,
                                        userData, launchIndex, groupNames, groupNamesSize))) {
        logprintfl (EUCAFATAL, "Error: could not allocate instance struct\n");
        return 2;
    }
    change_state(instance, STAGING);

    sem_p (inst_sem); 
    error = add_instance (&global_instances, instance);
    sem_v (inst_sem);
    if ( error ) {
        free_instance (&instance);
        logprintfl (EUCAFATAL, "Error: could not save instance struct\n");
        return error;
    }

    instance->launchTime = time (NULL);
    /*
      instance->params.mem = params->mem;
      instance->params.cores = params->cores;
      instance->params.disk = params->disk;
      strcpy (instance->ncnet.privateIp, "0.0.0.0");
      strcpy (instance->ncnet.publicIp, "0.0.0.0");
    */

    /* do the potentially long tasks in a thread */
    pthread_attr_t* attr = (pthread_attr_t*) malloc(sizeof(pthread_attr_t));
    if (!attr) { 
        free_instance (&instance);
        logprintfl (EUCAFATAL, "Warning: out of memory\n");
        return 1;
    }
    pthread_attr_init(attr);
    pthread_attr_setdetachstate(attr, PTHREAD_CREATE_DETACHED);
    
    if ( pthread_create (&(instance->tcb), attr, startup_thread, (void *)instance) ) {
        pthread_attr_destroy(attr);
        logprintfl (EUCAFATAL, "failed to spawn a VM startup thread\n");
        sem_p (inst_sem);
        remove_instance (&global_instances, instance);
        sem_v (inst_sem);
        free_instance (&instance);
	if (attr) free(attr);
        return 1;
    }
    pthread_attr_destroy(attr);
    if (attr) free(attr);

    * outInst = instance;
    return 0;

}

/*
 * Parse succesive blocks of XML data, generating events for the 
 * handlers/callbacks as we go. State is maintained in the 
 * simple_xml_parser object.
 * If the top level XML document ends before the last character, 
 * the "read" parameter indicates how much input was consumed.
 */
hcerr_t xml_parse(xml_parser *formal_parser, char s[], hc_long_t size, hc_long_t *read){
  simple_xml_parser *parser = (simple_xml_parser *)  formal_parser;

  int i = 0;

  if (DEBUG == TRUE){
    print_state(parser->state, parser->depth);
    printf ("in parser with " LL_FORMAT " %s\n", size, s);
    fflush(stdout);
  }

  while (i < size){

    switch(parser->state){

    case OUTSIDE_ELEMENT:
      if (is_white_space(s[i])){
	/*skip_white_space */
	break;
      }
      if (s[i] == '<'){
	parser->start_tag = TRUE;
	change_state(&parser->state, EXPECTING_OPEN_OR_CLOSE_TAG, parser->depth);
      }
      else {
	HC_ERR_LOG(("Expected '<', read %c at %d %s\n", s[i], i, s));
	return HCERR_XML_EXPECTED_LT;
      }
      break;
      
      
    case DOCUMENT_ELEMENT:
      /* discard document element */
      if (s[i] != '>'){
	if (DEBUG == TRUE)
	  printf("discarding %c", s[i]);
	break;
      }
      else{
	parser->state = OUTSIDE_ELEMENT;
	break;
      }

    case EXPECTING_OPEN_OR_CLOSE_TAG:
      if (is_white_space(s[i])){
	/*skip_white_space */
	break;
      }
      if (s[i] == '/'){
	if (DEBUG)
	  printf("parser->start_tag = FALSE\n");
	parser->start_tag = FALSE;
	break;
      }

    case EXPECTING_TAG:
      
      if (is_name_first_char(s[i]) == TRUE){
	change_state(&parser->state, SCANNING_TAG, parser->depth);
	require_ok(token_append(&parser->buffer_list, s[i]));
	break;
      }

      /* Discard document element */
      else if (s[i] == '?' && parser->depth == 0){
	parser->state = DOCUMENT_ELEMENT;
	break;
      }
      else{
	HC_ERR_LOG(("Invalid first character for element name : %c %d %s\n", s[i], i, s));
	return HCERR_XML_INVALID_ELEMENT_TAG;
      }
      
      // FALLTHRU INTENTIONAL???

      /* Start tag is terminated by whitespace, /, or >
	 End tag is terminated by whitespace or >
      */
    case SCANNING_TAG:
      /* Still reading token */
      if (is_name_char(s[i]) == TRUE){
	require_ok(token_append(&parser->buffer_list, s[i]));
	break;
      }
      else if (is_white_space(s[i]) == TRUE) {
	parser->current_tag = token_finish(&parser->buffer_list);
	if (parser->start_tag == TRUE){
	  /*printf("Start element: %s\n", parser->current_tag);*/
	  change_state(&parser->state, SCANNING_ATTRIBUTES, parser->depth);
	  break;
	}
	else{
	  change_state(&parser->state, SCANNING_CLOSE_TAG, parser->depth);
//.........这里部分代码省略.........

/* Constructs and queues a request packet describing the http query pointed
 * to by 'start'.
 */
int make_request_packet(Server *serv, int fd, int num_chars)
{
    struct sockaddr_in client_name, local_name;
    int client_namelen, local_namelen;
    int free_start, free_end;
    int packet_length;
    char *request;
    int len;

    client_namelen = sizeof(struct sockaddr_in);
    if (getpeername(fd, (struct sockaddr *) &client_name, &client_namelen) < 0)
    {
	syslog(LOG_INFO, "make_request_packet: failed to get peer "
		"name: %m\n");
	return 0;
    }
    local_namelen = sizeof(struct sockaddr_in);
    if (getsockname(fd, (struct sockaddr *) &local_name, &local_namelen) < 0)
    {
	syslog(LOG_INFO, "make_request_packet: failed to get sock name: %m\n");
	return 0;
    }
    change_state(serv, fd, fs_requested_backend);
    /* locate the free end of the buffer (possibly appending to previous
     * control packets) */
    append_data(serv, serv->control_fd, &free_start, &free_end, fs_output);
    /* reserve the first 4 bytes of the packet for the size field */
    packet_length = PAK_COM_OFF;
    /* add command field to packet */
    serv->writebuf.buffer[free_start + packet_length++] = PAK_REQUEST;
    /* add unique ID field to packet */
    write_long(&serv->writebuf.buffer[free_start], &packet_length,
	    (getpid() & 0xffff) | (fd << 16), 1);
    /* add client IP field to packet */
    write_long(&serv->writebuf.buffer[free_start], &packet_length,
	    client_name.sin_addr.s_addr, 0);
    /* add local IP field to packet */
    write_long(&serv->writebuf.buffer[free_start], &packet_length,
	    local_name.sin_addr.s_addr, 0);
    /* add local port field to packet */
    write_short(&serv->writebuf.buffer[free_start], &packet_length,
	    serv->port, 1);
    /* write the http headers */
    request = &serv->writebuf.buffer[serv->writebuf.pos[fd]];
    while (request[0] == '\r' || request[0] == '\n')
	request++;
    for (len = 0; len < num_chars && !isspace(request[len]); len++)
	;
    if (len < num_chars)
    {
	write_string(&serv->writebuf.buffer[free_start], &packet_length,
		"method");
	write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
		request, len);
	num_chars -= len;
	request += len;
	for (len = 0; len < num_chars && isspace(request[len]); len++)
	    ;
	if (len < num_chars)
	{
	    num_chars -= len;
	    request += len;
	    for (len = 0; request[len] && !isspace(request[len]); len++)
		;
	    write_string(&serv->writebuf.buffer[free_start], &packet_length,
		    "uri");
	    write_string_n(&serv->writebuf.buffer[free_start], &packet_length,
		    request, len);
	    num_chars -= len;
	    request += len;
	    for (len = 0; len < num_chars && isspace(request[len]); len++)
		;
	    if (len < num_chars)
	    {
		num_chars -= len;
		request += len;
		for (len = 0; request[len] && !isspace(request[len]); len++)
		    ;
		write_string(&serv->writebuf.buffer[free_start],
			&packet_length, "version");
		write_string_n(&serv->writebuf.buffer[free_start],
			&packet_length, request, len);
		/* each line should end with \r\n.  Be a bit lenient, and
		 * allow just \r or \n, too.  End of request is indicated
		 * by two such lines in a row */
		if (request[len] == '\r')
		    len++;
		if (request[len] == '\n')
		    len++;
		num_chars -= len;
		request += len;
		/* find "field: value\r\n" on successive lines, adding them
		 * to the buffer as field\0value\0 */
		while (num_chars > 0 && request[0] != '\r' &&
			request[0] != '\n')
		{
		    for (len = 0; len < num_chars && request[len] != ':' &&
//.........这里部分代码省略.........

void state_driving() {
    do_driving();
    do_shifting();
    change_state();
}

void key_pressed(unsigned short key) {
	switch (state) {
	case main_menu:
		switch (key) {
		case UP_ARROW_MAKECODE:
			previous_button(start_menu);
			break;
		case DOWN_ARROW_MAKECODE:
			next_button(start_menu);
			break;
		case ENTER_MAKECODE:
			press_selected_button(start_menu);
			break;
		case ESC_MAKECODE:
			cancel_button(start_menu);
			break;
		}
		break;
		case singleplayer:
			switch (key) {
			case ESC_MAKECODE: //TODO add a pause menu
				singleplayer_game_over();
				break;
			case RIGHT_ARROW_MAKECODE:
				if(controller == keyboard){
					singleplayer_move(1);
				}
				break;
			case LEFT_ARROW_MAKECODE:
				if(controller == keyboard){
					singleplayer_move(-1);
				}
				break;
			case SPACE_MAKECODE:
				if(controller == keyboard){
					singleplayer_fire();
				}
				break;
			}
			break;
			case multiplayer:
				switch(key){
				case A_MAKECODE:
					versus_mp_move(1,-1);
					break;
				case D_MAKECODE:
					versus_mp_move(1,1);
					break;

				case W_MAKECODE:
					versus_mp_fire(1);
					break;

				case LEFT_ARROW_MAKECODE:
					versus_mp_move(2,-1);
					break;

				case RIGHT_ARROW_MAKECODE:
					versus_mp_move(2,1);
					break;

				case UP_ARROW_MAKECODE:
					versus_mp_fire(2);
					break;

				case ESC_MAKECODE:
					change_state(main_menu);
					break;
				}
				break;
				case highscore:
					switch(key){
					case ESC_MAKECODE:
						highscore_back_on_click();
						break;
					}
					break;
					case options:
						switch(key){
						case ESC_MAKECODE:
							options_cancel_on_click();
							break;
						case ENTER_MAKECODE:
							options_accept_on_click();
							break;
						case RIGHT_ARROW_MAKECODE:
							options_next_ctrl_on_click();
							break;
						case LEFT_ARROW_MAKECODE:
							options_prev_ctrl_on_click();
							break;
						}
						break;
	}
}

 void event::remove_state(event_state new_state) {
   change_state(static_cast< event_state >(_state & ~new_state));
 }

static void usbIRQHandler(uint32_t token) {

	// we need to mask because GINTSTS is set for a particular interrupt even if it's masked in GINTMSK (GINTMSK just prevents an interrupt being generated)
	uint32_t status = GET_REG(USB + GINTSTS) & GET_REG(USB + GINTMSK);
	int process = FALSE;

	//uartPrintf("<begin interrupt: %x>\r\n", status);

	if(status) {
		process = TRUE;
	}

	while(process) {
		if((status & GINTMSK_OTG) == GINTMSK_OTG) {
			// acknowledge OTG interrupt (these bits are all R_SS_WC which means Write Clear, a write of 1 clears the bits)
			SET_REG(USB + GOTGINT, GET_REG(USB + GOTGINT));

			// acknowledge interrupt (this bit is actually RO, but should've been cleared when we cleared GOTGINT. Still, iBoot pokes it as if it was WC, so we will too)
			SET_REG(USB + GINTSTS, GINTMSK_OTG);

			process = TRUE;
		} else {
			// we only care about OTG
			process = FALSE;
		}

		if((status & GINTMSK_RESET) == GINTMSK_RESET) {
			bufferPrintf("usb: reset detected\r\n");
			change_state(USBPowered);

			int retval = resetUSB();

			SET_REG(USB + GINTSTS, GINTMSK_RESET);

			if(retval) {
				bufferPrintf("usb: listening for further usb events\r\n");
				return;	
			}

			process = TRUE;
		}

		if(((status & GINTMSK_INEP) == GINTMSK_INEP) || ((status & GINTMSK_OEP) == GINTMSK_OEP)) {
			// aha, got something on one of the endpoints. Now the real fun begins

			// first, let's get the interrupt status of individual endpoints
			getEndpointInterruptStatuses();

			if(isSetupPhaseDone()) {
				// recall our earlier receiveControl calls. We now should have 8 bytes of goodness in controlRecvBuffer.
				USBSetupPacket* setupPacket = (USBSetupPacket*) controlRecvBuffer;

				uint16_t length;
				uint32_t totalLength;
				USBStringDescriptor* strDesc;
				if(USBSetupPacketRequestTypeType(setupPacket->bmRequestType) != USBSetupPacketVendor) {
					switch(setupPacket->bRequest) {
						case USB_GET_DESCRIPTOR:
							length = setupPacket->wLength;
							// descriptor type is high, descriptor index is low
							int stall = FALSE;
							switch(setupPacket->wValue >> 8) {
								case USBDeviceDescriptorType:
									if(length > sizeof(USBDeviceDescriptor))
										length = sizeof(USBDeviceDescriptor);

									memcpy(controlSendBuffer, usb_get_device_descriptor(), length);
									break;
								case USBConfigurationDescriptorType:
									// hopefully SET_ADDRESS was received beforehand to set the speed
									totalLength = getConfigurationTree(setupPacket->wValue & 0xFF, usb_speed, controlSendBuffer);
									if(length > totalLength)
										length = totalLength;
									break;
								case USBStringDescriptorType:
									strDesc = usb_get_string_descriptor(setupPacket->wValue & 0xFF);
									if(length > strDesc->bLength)
										length = strDesc->bLength;
									memcpy(controlSendBuffer, strDesc, length);
									break;
								case USBDeviceQualifierDescriptorType:
									if(length > sizeof(USBDeviceQualifierDescriptor))
										length = sizeof(USBDeviceQualifierDescriptor);

									memcpy(controlSendBuffer, usb_get_device_qualifier_descriptor(), length);
									break;
								default:
									bufferPrintf("Unknown descriptor request: %d\r\n", setupPacket->wValue >> 8);
									stall = TRUE;
							}

							if(gUsbState < USBError) {
								if(stall)
									stallControl();
								else
									sendControl(controlSendBuffer, length);
							}

							break;

//.........这里部分代码省略.........

int main()
{
    // instantiate the app class
    App *app = new App();


    // gaffer loop time stuff
    sf::Clock clock;

    //double dt = 0.01f;
    //const double dt = 1.0f / 60.0f; // this is same as timeStep
    double alpha;

    double currentTime = clock.getElapsedTime().asSeconds();
    double accumulator = 0.0f;

    // get a clock for calculating fps
    sf::Clock fps_clock;
    double lasttime = 0;

    // set initial state
    stateID = STATE_TITLE;
    currentState.reset(new Title(app));
    pausedState.reset(new Pause(app));

    // init the state stack TODO - just work with the stack directly instead of currentState?
    //std::vector<GameState>& state_stack;



    // main loop here
    while(stateID != STATE_EXIT)
    {
        double newTime = clock.getElapsedTime().asSeconds();
        double frameTime = newTime - currentTime; // remove division by 1000 if using seconds

        if (frameTime > 0.55f) // was 0.25
            frameTime = 0.55f;

        currentTime = newTime;
        accumulator += frameTime;

        // handle events
        currentState->handle_events(app);

        // fixed timestep update loop
        int count = 0;
        while ( accumulator >= app->TIMESTEP )
        {
            //if (stateID != STATE_PAUSE)
            // do logic for current state
            currentState->logic(app);

            // decrement accumulator
            accumulator -= app->TIMESTEP;
            count += 1;
        }

        //std::cout << count << std::endl;

        // get the alpha
        alpha = accumulator / app->TIMESTEP;

        // change state if needed
        change_state(app);

        // render the state
        currentState->render(app, alpha);

        // update screen
        app->window.display();

        // calculate FPS
        double fps_time = fps_clock.restart().asSeconds();
        app->fps = 1 / (fps_time - lasttime);
        //std::cout << "state: " << stateID << "fps: " << fps << "  accumulator: " << accumulator << "  alpha: " << alpha << "  frameTime: " << frameTime << std::endl;
    }
    // do cleanup
    clean_up(app);
}

int main(int argc, char **argv)
{
	enum state state;
	unsigned char	command;
   struct timeval	tval;
	struct packet	pkt;

	/* Open a socket and start listening to a scpefied port */
	open_udp_socket();
	srand(time(NULL));

	/* Startup: */
	build_send_packet(BROADCAST, CMD_MASTERREQ, 0); /* Search for a master */
	change_state(&state, STATE_STARTUP, &tval, NULL);

   for(;;)
   {
      struct timeval curtime;
      gettimeofday(&curtime, NULL);

		printf("  ");
		print_time(&curtime);
      /*printf(" TIME: %10d sec %10d usec\n",
				(unsigned int)curtime.tv_sec, (unsigned int)curtime.tv_usec);*/

      recv_msg(&pkt, &tval);

		command = pkt.type;
		//printf("Command received = %d\n", command);

      switch(state | command)
      {
			/*    STARTUP    */
         case(STATE_STARTUP | CMD_TIMEOUT):
				build_send_packet(BROADCAST, CMD_MASTERUP, 0);
            change_state(&state, STATE_MASTER, &tval, &master_timeout);
            break;

			case(STATE_STARTUP | CMD_MASTERUP):
				build_send_packet(pkt.ip, CMD_SLAVEUP, 0);
				// no break;
			case(STATE_STARTUP | CMD_MASTERREQ):
			case(STATE_STARTUP | CMD_MASTERACK):
			case(STATE_STARTUP | CMD_ELECTION):
				change_state(&state, STATE_SLAVE, &tval, NULL);
				break;

			/*    MASTER    */
			/* Launch a new thread and process separately? Prevents loss of messages */
			case(STATE_MASTER | CMD_TIMEOUT):
				/* Does the Master needs to send his clock? */
				build_send_packet(BROADCAST, CMD_CLOCKREQ, 1);
				//change_state(&state, STATE_MASTER, &tval, MASTER_TIMEOUT);
				/* Change to an intermediate state in order to wait for all slaves
				 * to send their clocks. After the MASTER_ADJTIME_TIMEOUT no more clock
				 * packets will be accepted and the "slow" slaves, if any, won't
				 * be synchronized*/
				change_state(&state, STATE_MASTER_ADJTIME, &tval, &master_adjtime_timeout);
				/* Possibly new thread? Non blocking function...*/
				adjust_master_prepare();
				break;

			case(STATE_MASTER | CMD_MASTERREQ):
				build_send_packet(pkt.ip, CMD_MASTERACK, 0);
				break;

			case(STATE_MASTER | CMD_QUIT):
				build_send_packet(pkt.ip, CMD_ACK, 0);
				change_state(&state, STATE_SLAVE, &tval, NULL);
				break;

			case(STATE_MASTER | CMD_ELECTION):
			case(STATE_MASTER | CMD_MASTERUP):
				build_send_packet(pkt.ip, CMD_QUIT, 0);
				break;

         /*    MASTER_ADJTIME    */
			case(STATE_MASTER_ADJTIME | CMD_CLOCKREQ_RESPONSE):
				/* Got time from client */
				adjust_master_addslave(pkt.ip, &pkt.time);
				break;

			case(STATE_MASTER_ADJTIME | CMD_TIMEOUT):
				/* Calculate avg clocks and send to each slave his correction */
				/* Restart the synchronization timer */
				change_state(&state, STATE_MASTER, &tval, &master_timeout);
				adjust_master_calcandsend();
				break;

         /*    SLAVE    */
         case(STATE_SLAVE | CMD_CLOCKREQ):
				/* Send clock packet to master and change to an intermediate state
				 * in order to wait for a synch packet */
				build_send_packet(pkt.ip, CMD_CLOCKREQ_RESPONSE, 1);
            change_state(&state, STATE_SLAVE, &tval, NULL);
            break;

			case(STATE_SLAVE | CMD_TIMEOUT):
				build_send_packet(BROADCAST, CMD_ELECTION, 0);
				change_state(&state, STATE_CANDIDATE, &tval, &candidate_timeout);
//.........这里部分代码省略.........

void state_isotp() {
	int i, items, ret;

	char rxmsg[MAXLEN]; /* can to inet */
	char buf[MAXLEN]; /* inet commands to can */
	unsigned char isobuf[ISOTPLEN+1]; /* binary buffer for isotp socket */
	unsigned char tmp;
	
	if(previous_state == STATE_ISOTP) {
		state_isotp_init();
		previous_state = STATE_ISOTP;
	}

	FD_ZERO(&readfds);
	FD_SET(si, &readfds);
	FD_SET(client_socket, &readfds);

	/*
	 * Check if there are more elements in the element buffer before calling select() and
	 * blocking for new packets.
	 */
	if(more_elements) {
		FD_CLR(si, &readfds);
	} else {
		ret = select((si > client_socket)?si+1:client_socket+1, &readfds, NULL, NULL, NULL);
		if(ret < 0) {
			PRINT_ERROR("Error in select()\n")
			change_state(STATE_SHUTDOWN);
			return;
		}
	}

	if (FD_ISSET(si, &readfds)) {

		struct timeval tv = {0};

		items = read(si, isobuf, ISOTPLEN);

		/* read timestamp data */
		if(ioctl(si, SIOCGSTAMP, &tv) < 0) {
			PRINT_ERROR("Could not receive timestamp\n");
		}

		if (items > 0 && items <= ISOTPLEN) {

			int startlen;

			sprintf(rxmsg, "< pdu %ld.%06ld ", tv.tv_sec, tv.tv_usec);
			startlen = strlen(rxmsg);

			for (i=0; i < items; i++)
				sprintf(rxmsg + startlen + 2*i, "%02X", isobuf[i]);

			sprintf(rxmsg + strlen(rxmsg), " >");
			send(client_socket, rxmsg, strlen(rxmsg), 0);
		}
	}

	if (FD_ISSET(client_socket, &readfds)) {

		ret = receive_command(client_socket, buf);
		if(ret != 0) {
			change_state(STATE_SHUTDOWN);
			return;
		}

		if ( (ret = state_changed(buf, state)) ) {
			if(ret == CONTROL_SWITCH_STATE) state_isotp_deinit();
			strcpy(buf, "< ok >");
			send(client_socket, buf, strlen(buf), 0);
			return;
		}

#if 0
		if(!strcmp("< echo >", buf)) {
			send(client_socket, buf, strlen(buf), 0);
			return;
		}

		if(!strncmp("< sendpdu ", buf, 10)) {
			items = element_length(buf, 2);
			if (items & 1) {
				PRINT_ERROR("odd number of ASCII Hex values\n");
				return;
			}

			items /= 2;
			if (items > ISOTPLEN) {
				PRINT_ERROR("PDU too long\n");
				return;
			}

			for (i = 0; i < items; i++) {

				tmp = asc2nibble(buf[(2*i) + 10]);
				if (tmp > 0x0F)
					return;
				isobuf[i] = (tmp << 4);
				tmp = asc2nibble(buf[(2*i) + 11]);
				if (tmp > 0x0F)
//.........这里部分代码省略.........

void
g_omx_core_pause (GOmxCore *core)
{
    change_state (core, OMX_StatePause);
    wait_for_state (core, OMX_StatePause);
}

void state_isotp_init() {

	int items, ret;

	struct sockaddr_can addr;
	struct ifreq ifr;
	static struct can_isotp_options opts;
	static struct can_isotp_fc_options fcopts;

	char buf[MAXLEN]; /* inet commands to can */

	while(previous_state != STATE_ISOTP) {

		ret = receive_command(client_socket, buf);
		if(ret != 0) {
			change_state(STATE_SHUTDOWN);
			return;
		}

		strncpy(ifr.ifr_name, bus_name, IFNAMSIZ);

		if ( (ret = state_changed(buf, state)) ) {
			/* ensure proper handling in other states */
			if(ret == CONTROL_SWITCH_STATE) previous_state = STATE_ISOTP;
			strcpy(buf, "< ok >");
			send(client_socket, buf, strlen(buf), 0);
			return;
		}
#if 0
		if(!strcmp("< echo >", buf)) {
			send(client_socket, buf, strlen(buf), 0);
			continue;
		}

		memset(&opts, 0, sizeof(opts));
		memset(&fcopts, 0, sizeof(fcopts));
		memset(&addr, 0, sizeof(addr));

		/* get configuration to open the socket */
		if(!strncmp("< isotpconf ", buf, 12)) {
			items = sscanf(buf, "< %*s %x %x %x "
				       "%hhu %hhx %hhu "
				       "%hhx %hhx %hhx %hhx >",
				       &addr.can_addr.tp.tx_id,
				       &addr.can_addr.tp.rx_id,
				       &opts.flags,
				       &fcopts.bs,
				       &fcopts.stmin,
				       &fcopts.wftmax,
				       &opts.txpad_content,
				       &opts.rxpad_content,
				       &opts.ext_address,
				       &opts.rx_ext_address);

			/* < isotpconf XXXXXXXX ... > check for extended identifier */
			if(element_length(buf, 2) == 8)
				addr.can_addr.tp.tx_id |= CAN_EFF_FLAG;

			if(element_length(buf, 3) == 8)
				addr.can_addr.tp.rx_id |= CAN_EFF_FLAG;

			if (((opts.flags & CAN_ISOTP_RX_EXT_ADDR) && items < 10) ||
			    ((opts.flags & CAN_ISOTP_EXTEND_ADDR) && items < 9) ||
			    ((opts.flags & CAN_ISOTP_RX_PADDING) && items < 8) ||
			    ((opts.flags & CAN_ISOTP_TX_PADDING) && items < 7) ||
			    (items < 5)) {
				PRINT_ERROR("Syntax error in isotpconf command\n");
				/* try it once more */
				continue;
			}

			/* open ISOTP socket */
			if ((si = socket(PF_CAN, SOCK_DGRAM, CAN_ISOTP)) < 0) {
				PRINT_ERROR("Error while opening ISOTP socket %s\n", strerror(errno));
				/* ensure proper handling in other states */
				previous_state = STATE_ISOTP;
				state_isotp_deinit();
				change_state(STATE_SHUTDOWN);
				return;
			}

			strcpy(ifr.ifr_name, bus_name);
			if(ioctl(si, SIOCGIFINDEX, &ifr) < 0) {
				PRINT_ERROR("Error while searching for bus %s\n", strerror(errno));
				/* ensure proper handling in other states */
				previous_state = STATE_ISOTP;
				state_isotp_deinit();
				change_state(STATE_SHUTDOWN);
				return;
			}

			addr.can_family = PF_CAN;
			addr.can_ifindex = ifr.ifr_ifindex;

			/* only change the built-in defaults when required */
			if (opts.flags)
				setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_OPTS, &opts, sizeof(opts));

			setsockopt(si, SOL_CAN_ISOTP, CAN_ISOTP_RECV_FC, &fcopts, sizeof(fcopts));

//.........这里部分代码省略.........

//.........这里部分代码省略.........
          send_port = atoi(argv[CLARG_ACTION + 1]);
          recv_port = atoi(argv[CLARG_ACTION + 2]);
        } else {
          usage(argv[0]);
          return 1;
        }
      }
    }
  }
  if (action == action_none) {
    usage(argv[0]);
    return 1;
  }

  size_t i = 0;
  for (i = 0; i < argc; i++)
  {
    if(strcmp(argv[i],"log") == 0){
      time_t timev;
      time(&timev);
      char timedate[256];
      strftime(timedate, 256, "var/logs/%Y%m%d_%H%M%S.rssilog", localtime(&timev));
      rssi_fp = fopen(timedate, "w");
      if (!rssi_fp)
      {
	fprintf(stderr,"Unable to open file for logging: %s\n Make sure to run from paparazzi home\n", timedate);
	return -1;
      }
    }
  }

  // set BGLib output function pointer to "send_api_packet" function
  bglib_output = send_api_packet;

  if (uart_open(uart_port)) {
    fprintf(stderr, "ERROR: Unable to open serial port - %s\n", strerror(errno));
    return 1;
  }

  // Reset dongle to get it into known state
  ble_cmd_system_reset(0);

#if 0 // very soft "reset"
  // close current connection, stop scanning, stop advertising
  // (returns BLE device to a known state without a hard reset)
  ble_cmd_connection_disconnect(0);
  ble_cmd_gap_set_mode(0, 0);
  ble_cmd_gap_end_procedure();

#else // full reset
  // reset BLE device to get it into known state
  ble_cmd_system_reset(0);

  // close the serial port, since reset causes USB to re-enumerate
  uart_close();

  // wait until USB re-enumerates and we can re-open the port
  // (not necessary if using a direct UART connection)
  do {
    usleep(500000); // 0.5s
  } while (uart_open(uart_port));
#endif

  // get the mac address of the dongle
  ble_cmd_system_address_get();

  // advertise interval scales 625us, min, max, channels (0x07 = 3, 0x03 = 2, 0x04 = 1)
  if (action == action_broadcast)
    ble_cmd_gap_set_adv_parameters(0x20, 0x28, 0x07);
    
  // Execute action
  if (action == action_scan || action == action_broadcast || action == action_broadcast_connect) {
    ble_cmd_gap_discover(gap_discover_generic);
  } else if (action == action_info) {
    ble_cmd_system_get_info();
  } else if (action == action_connect) {
    fprintf(stderr, "Trying to connect\n");
    change_state(state_connecting);
    ble_cmd_gap_connect_direct(&connect_addr, gap_address_type_public, 8, 16, 100, 0);
  }

  pthread_create(&threads[0], NULL, send_msg, NULL);
  pthread_create(&threads[1], NULL, recv_paparazzi_comms, NULL);

  // Message loop
  while (state != state_finish) {
    if (read_api_packet(UART_TIMEOUT) > 0) { break; }
  }

  change_state(state_finish);

  ble_cmd_gap_end_procedure();

  uart_close();

  pthread_exit(NULL);

  if (rssi_fp)
    fclose(rssi_fp);
}

/**
 * "connection_status" event handler
 * Occurs whenever a new connection is established, or an existing one is updated
 *
 * @param msg Event packet data payload
 */
void ble_evt_connection_status(const struct ble_msg_connection_status_evt_t *msg)
{
  // updated connection
  if (msg->flags & connection_parameters_change) {
    fprintf(stderr, "Connection %d parameters updated, interval %fms\n", msg->connection, msg->conn_interval * 1.25);
  }

  // Encrypted previous connection
  else if (msg->flags & connection_encrypted) {
    fprintf(stderr, "Connection with %d is encrypted\n", msg->connection);
  }

  // Connection request completed
  else if (msg->flags & connection_completed) {
    if (msg->connection + 1 > connected_devices) { connected_devices++; }
    cpy_bdaddr(connected_addr[msg->connection].addr, msg->address.addr);
    //change_state(state_connected);
    connection_interval = msg->conn_interval * 1.25;
    fprintf(stderr, "Connected, nr: %d, connection interval: %d = %fms\n", msg->connection, msg->conn_interval,
            msg->conn_interval * 1.25);
    connected[msg->connection] = 1;

    if (rec_addr[msg->connection].sin_family != AF_INET && send_port && recv_port) {
      if ((sock[msg->connection] = socket(AF_INET, SOCK_DGRAM, 0)) == -1) {
        perror("socket");
        exit(1);
      }

      send_addr[msg->connection].sin_family = AF_INET;
      send_addr[msg->connection].sin_port = htons(send_port + msg->connection);
      send_addr[msg->connection].sin_addr = *((struct in_addr *)host->h_addr);
      bzero(&(send_addr[msg->connection].sin_zero), 8);
      sin_size = sizeof(struct sockaddr);

      rec_addr[msg->connection].sin_family = AF_INET;
      rec_addr[msg->connection].sin_port = htons(recv_port + msg->connection);
      rec_addr[msg->connection].sin_addr = *((struct in_addr *)host->h_addr);
      bzero(&(rec_addr[msg->connection].sin_zero), 8);
      sin_size = sizeof(struct sockaddr);

      if (bind(sock[msg->connection], (struct sockaddr *)&rec_addr[msg->connection],
               sizeof(struct sockaddr)) == -1) {
        perror("Bind failed");
        exit(1);
      }
      fprintf(stderr, "Comms port opened on port: %d %d\n", send_port + msg->connection, recv_port + msg->connection);
    }

    // Handle for Drone Data configuration already known
    if (drone_handle_configuration) {
      change_state(state_listening_measurements);
      enable_indications(msg->connection, drone_handle_configuration);
      //if (connect_all) {
	      ble_cmd_gap_discover(gap_discover_generic);
      //}
    }
    // Find primary services
    else {
      change_state(state_finding_services);
      ble_cmd_attclient_read_by_group_type(msg->connection, FIRST_HANDLE, LAST_HANDLE, 2, primary_service_uuid);
      //if (connect_all) {
	      ble_cmd_gap_discover(gap_discover_generic);
      //}
    }
  }
}

bool cassette_image_device::call_load()
{
	casserr_t err;
	int cassette_flags;
	const char *extension;
	int is_writable;
	device_image_interface *image = nullptr;
	interface(image);

	if ((has_been_created()) || (length() == 0))
	{
		/* creating an image */
		err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);
		if (err)
			goto error;
	}
	else
	{
		/* opening an image */
		do
		{
			is_writable = !is_readonly();
			cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
			std::string fname;
			if (software_entry()==nullptr) {
				extension = filetype();
			} else {
				fname = m_mame_file->filename();
				int loc = fname.find_last_of('.');
				if (loc!=-1) {
					extension = fname.substr(loc + 1,fname.length()-loc).c_str();
				} else {
					extension = "";
				}
			}
			err = cassette_open_choices((void *)image, &image_ioprocs, extension, m_formats, cassette_flags, &m_cassette);

			/* this is kind of a hack */
			if (err && is_writable)
				make_readonly();
		}
		while(err && is_writable);

		if (err)
			goto error;
	}

	/* set to default state, but only change the UI state */
	change_state(m_default_state, CASSETTE_MASK_UISTATE);

	/* reset the position */
	m_position = 0.0;
	m_position_time = device().machine().time().as_double();

	/* default channel to 0, speed multiplier to 1 */
	m_channel = 0;
	m_speed = 1;
	m_direction = 1;

	return IMAGE_INIT_PASS;

error:
	image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
	switch(err)
	{
		case CASSETTE_ERROR_INTERNAL:
			imgerr = IMAGE_ERROR_INTERNAL;
			break;
		case CASSETTE_ERROR_UNSUPPORTED:
			imgerr = IMAGE_ERROR_UNSUPPORTED;
			break;
		case CASSETTE_ERROR_OUTOFMEMORY:
			imgerr = IMAGE_ERROR_OUTOFMEMORY;
			break;
		case CASSETTE_ERROR_INVALIDIMAGE:
			imgerr = IMAGE_ERROR_INVALIDIMAGE;
			break;
		default:
			imgerr = IMAGE_ERROR_UNSPECIFIED;
			break;
	}
	image->seterror(imgerr, "" );
	return IMAGE_INIT_FAIL;
}

static void
refresh_instance_info(	struct nc_state_t *nc,
			ncInstance *instance)
{
    int now = instance->state;
    
    if (! check_hypervisor_conn ())
	    return;

    /* no need to bug for domains without state on Hypervisor */
    if (now==TEARDOWN || now==STAGING)
        return;
    
    sem_p(hyp_sem);
    virDomainPtr dom = virDomainLookupByName (nc_state.conn, instance->instanceId);
    sem_v(hyp_sem);
    if (dom == NULL) { /* hypervisor doesn't know about it */
      if (now==RUNNING ||
            now==BLOCKED ||
            now==PAUSED ||
            now==SHUTDOWN) {
            /* Most likely the user has shut it down from the inside */
            if (instance->retries) {
		instance->retries--;
		logprintfl (EUCAWARN, "warning: hypervisor failed to find domain %s, will retry %d more times\n", instance->instanceId, instance->retries);	
            } else {
            	logprintfl (EUCAWARN, "warning: hypervisor failed to find domain %s, assuming it was shut off\n", instance->instanceId);
            	change_state (instance, SHUTOFF);
            }
        }
        /* else 'now' stays in SHUTFOFF, BOOTING, CANCELED, or CRASHED */
        return;
    }
    virDomainInfo info;
    sem_p(hyp_sem);
    int error = virDomainGetInfo(dom, &info);
    sem_v(hyp_sem);
    if (error < 0 || info.state == VIR_DOMAIN_NOSTATE) {
        logprintfl (EUCAWARN, "warning: failed to get informations for domain %s\n", instance->instanceId);
        /* what to do? hopefully we'll find out more later */
	sem_p(hyp_sem);
        virDomainFree (dom);
	sem_v(hyp_sem);
        return;
    } 
    int xen = info.state;

    switch (now) {
    case BOOTING:
    case RUNNING:
    case BLOCKED:
    case PAUSED:
        /* change to state, whatever it happens to be */
        change_state (instance, xen);
        break;
    case SHUTDOWN:
    case SHUTOFF:
    case CRASHED:
        if (xen==RUNNING ||
            xen==BLOCKED ||
            xen==PAUSED) {
            /* cannot go back! */
            logprintfl (EUCAWARN, "warning: detected prodigal domain %s, terminating it\n", instance->instanceId);
            sem_p (hyp_sem);
            virDomainDestroy (dom);
            sem_v (hyp_sem);
        } else {
            change_state (instance, xen);
        }
        break;
    default:
        logprintfl (EUCAERROR, "error: refresh...(): unexpected state (%d) for instance %s\n", now, instance->instanceId);
        return;
    }
    sem_p(hyp_sem);
    virDomainFree(dom);
    sem_v(hyp_sem);

    /* if instance is running, try to find out its IP address */
    if (instance->state==RUNNING ||
        instance->state==BLOCKED ||
        instance->state==PAUSED) {
        char *ip=NULL;
        int rc;

        if (!strncmp(instance->ncnet.publicIp, "0.0.0.0", 24)) {
	  if (!strcmp(nc_state.vnetconfig->mode, "SYSTEM") || !strcmp(nc_state.vnetconfig->mode, "STATIC")) {
            rc = mac2ip(nc_state.vnetconfig, instance->ncnet.privateMac, &ip);
            if (!rc) {
	      if(ip) {
	        logprintfl (EUCAINFO, "discovered public IP %s for instance %s\n", ip, instance->instanceId);
	        strncpy(instance->ncnet.publicIp, ip, 24);
	        free(ip);
	      }
            }
	  }
        }
        if (!strncmp(instance->ncnet.privateIp, "0.0.0.0", 24)) {
            rc = mac2ip(nc_state.vnetconfig, instance->ncnet.privateMac, &ip);
            if (!rc) {
//.........这里部分代码省略.........

void *
monitoring_thread (void *arg)
{
	int i;
	struct nc_state_t *nc;

	if (arg == NULL) {
		logprintfl (EUCAFATAL, "NULL parameter!\n");
		return NULL;
	}
	nc = (struct nc_state_t*)arg;

	logprintfl (EUCADEBUG, "Starting monitoring thread\n!\n");

    for (;;) {
        bunchOfInstances *head;
        time_t now = time(NULL);
        sem_p (inst_sem);

        for ( head = global_instances; head; head = head->next ) {
            ncInstance * instance = head->instance;

            /* query for current state, if any */
	    refresh_instance_info (nc, instance);

            /* don't touch running or canceled threads */
            if (instance->state!=STAGING && instance->state!=BOOTING && 
                instance->state!=SHUTOFF &&
                instance->state!=SHUTDOWN &&
                instance->state!=TEARDOWN) continue;

            if (instance->state==TEARDOWN) {
                /* it's been long enough, we can forget the instance */
                if ((now - instance->terminationTime)>teardown_state_duration) {
                    remove_instance (&global_instances, instance);
                    logprintfl (EUCAINFO, "forgetting about instance %s\n", instance->instanceId);
                    free_instance (&instance);
		    break;	/* need to get out since the list changed */
                }
                continue;
            }

	    // time out logic for STAGING or BOOTING instances
            if (instance->state==STAGING  
		&& (now - instance->launchTime)   < staging_cleanup_threshold) continue; // hasn't been long enough, spare it
            if (instance->state==BOOTING  
		&& (now - instance->bootTime)     < booting_cleanup_thres