예제 #1
0
void Debugger::Run() {
  pc_modified_ = false;
  while (pc_ != kEndOfSimAddress) {
    if (pending_request()) RunDebuggerShell();
    ExecuteInstruction();
  }
}
예제 #2
0
/* processing with map-request */
	int 
generic_process_request(uint32_t request_id, struct communication_fct * fct){
	struct db_table * table;
	struct db_node * rn = NULL;
	struct prefix p;
	int is_ddt;
	struct db_node *node = NULL, *np;
	int rt;
	
	/* look for the eid */
	
	fct->request_get_eid(request_id, &p);
	table = ms_get_db_table(ms_db,&p);
	rn = db_node_match_prefix(table, &p);
			
	if(!rn){
		_request_reply_negative(request_id, fct, rn, &p, 900, 0, 1,	0);
		fct->request_terminate(request_id);
		return (FALSE);
	}
	
	fct->request_is_ddt(request_id, &is_ddt);

	/* Received DDT request */
	if(is_ddt){
		/*function of {map-register-with-DDT|DDT-node}*/
		node = rn;
		if( !rn->flags || !((struct mapping_flags *)rn->flags)->range){
			node = ms_get_target(rn);
		}
					
		if (ms_node_is_type(node, _MAPP)){
			/* Only send map-referrel for EDI-prefix auth */
			if( !((struct mapping_flags *)node->flags)->referral){
				if(ms_node_is_proxy_reply(node)){
					rt = _request_reply(request_id, fct, node, NULL);
					fct->request_terminate(request_id);	
					return rt;
				}
				 else{
					 fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
					 _request_referral(request_id, fct, node);
					 rt = _forward_to_etr(request_id,node);
					fct->request_terminate(request_id);	
					return rt;
				 }
			}
			
			if( ((struct mapping_flags *)node->flags)->referral && ((struct mapping_flags *)node->flags)->A){
				rt =  _request_referral(request_id, fct, node);
				fct->request_terminate(request_id);	
				return rt;
			}
			
			if( ((struct mapping_flags *)node->flags)->referral && !((struct mapping_flags *)node->flags)->A){
				np = node;
				while(np != table->top){
					if (((struct mapping_flags *)np->flags)->referral && ((struct mapping_flags *)np->flags)->A)
						break;		
					np = np->parent;			
				}
				if ( (np != table->top) && ((struct mapping_flags *)np->flags)->referral && ((struct mapping_flags *)np->flags)->A){				
					rt =  _request_referral(request_id, fct, np);
					fct->request_terminate(request_id);	
					return rt;
				}	
			}
			
		}
		else{
			if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID)){
				rt =  _request_referral_negative(request_id, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);	
				fct->request_terminate(request_id);	
				return rt;
			}
			else{ 
				if ( ms_node_is_type(node,_GREID) ){  
					rt = _request_referral_negative(request_id, fct, rn, &p, 60, 0, LISP_REFERRAL_DELEGATION_HOLE,0, 1 );				
					fct->request_terminate(request_id);	
					return rt;
				}	
				else{
					rt = _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);
					fct->request_terminate(request_id);	
					return rt;
				}
			}	
		}	
		
		printf("Not process\n");
		return (0);
	}
	/* Received non DDT request */
	else{
		//function of {map-resolver |map-register-with-no-DDD-function}
		node = rn;
		
		if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
			node = ms_get_target(rn);
		}
			
		if ( ms_node_is_type(node, _MAPP)){
			if( !ms_node_is_referral(node)){
				if(ms_node_is_proxy_reply(node)){
					rt =  _request_reply(request_id, fct, node, NULL);
					fct->request_terminate(request_id);	
					return rt;
				}
				 else{
					 fprintf(OUTPUT_STREAM, "Forwarding to ETR\n");
					 rt = _forward_to_etr(request_id,node);	
					 fct->request_terminate(request_id);	
					return rt;	
				 }				
			}
			else{
				pending_request(request_id, fct, node);	
				fct->request_terminate(request_id);
				return 1;
			}
		}
		else{
			if ( ms_node_is_type(node,_EID) || ms_node_is_type(node,_GEID)){
				if ( ms_node_is_type(node,_EID))
					rt = _request_reply_negative(request_id, fct, node, &p, 60, 1, 1, 0);	
				else
					rt = _request_reply_negative(request_id, fct, node, &p, 900, 1, 1, 0);	
				
				fct->request_terminate(request_id);	
				return rt;
			}
			else{
				if ( ms_node_is_type(node,_GREID) )  {
					rt = _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);
					fct->request_terminate(request_id);	
					return rt;
				}
				else{
					rt =  _request_reply_negative(request_id, fct, node, &p, 900, 0, 1, 0);		
					fct->request_terminate(request_id);	
					return rt;
				}
			}
		}	
	}	
	printf("Not process\n");
	return (0);		
	
	assert(FALSE);
}
예제 #3
0
void EXTI4_IRQHandler (void)
{
    if (ptr_ITHandler_ext)
        (*ptr_ITHandler_ext) ();
    pending_request(4);
}
예제 #4
0
/* -------------------------------------------
 afp over dsi. this never returns. 
*/
void afp_over_dsi(AFPObj *obj)
{
    DSI *dsi = (DSI *) obj->handle;
    int rc_idx;
    u_int32_t err, cmd;
    u_int8_t function;

    AFPobj = obj;
    obj->exit = afp_dsi_die;
    obj->reply = (int (*)()) dsi_cmdreply;
    obj->attention = (int (*)(void *, AFPUserBytes)) dsi_attention;
    dsi->tickle = 0;

    afp_over_dsi_sighandlers(obj);

    if (dircache_init(obj->options.dircachesize) != 0)
        afp_dsi_die(EXITERR_SYS);

    /* set TCP snd/rcv buf */
    if (obj->options.tcp_rcvbuf) {
        if (setsockopt(dsi->socket,
                       SOL_SOCKET,
                       SO_RCVBUF,
                       &obj->options.tcp_rcvbuf,
                       sizeof(obj->options.tcp_rcvbuf)) != 0) {
            LOG(log_error, logtype_dsi, "afp_over_dsi: setsockopt(SO_RCVBUF): %s", strerror(errno));
        }
    }
    if (obj->options.tcp_sndbuf) {
        if (setsockopt(dsi->socket,
                       SOL_SOCKET,
                       SO_SNDBUF,
                       &obj->options.tcp_sndbuf,
                       sizeof(obj->options.tcp_sndbuf)) != 0) {
            LOG(log_error, logtype_dsi, "afp_over_dsi: setsockopt(SO_SNDBUF): %s", strerror(errno));
        }
    }

    /* set TCP_NODELAY */
    int flag = 1;
    setsockopt(dsi->socket, SOL_TCP, TCP_NODELAY, &flag, sizeof(flag));

    /* get stuck here until the end */
    while (1) {
        if (sigsetjmp(recon_jmp, 1) != 0)
            /* returning from SIGALARM handler for a primary reconnect */
            continue;

        /* Blocking read on the network socket */
        cmd = dsi_stream_receive(dsi);

        if (cmd == 0) {
            /* cmd == 0 is the error condition */
            if (dsi->flags & DSI_RECONSOCKET) {
                /* we just got a reconnect so we immediately try again to receive on the new fd */
                dsi->flags &= ~DSI_RECONSOCKET;
                continue;
            }

            /* the client sometimes logs out (afp_logout) but doesn't close the DSI session */
            if (dsi->flags & DSI_AFP_LOGGED_OUT) {
                LOG(log_note, logtype_afpd, "afp_over_dsi: client logged out, terminating DSI session");
                afp_dsi_close(obj);
                exit(0);
            }

#if 0
            /*  got ECONNRESET in read from client => exit*/
            if (dsi->flags & DSI_GOT_ECONNRESET) {
                LOG(log_note, logtype_afpd, "afp_over_dsi: client connection reset");
                afp_dsi_close(obj);
                exit(0);
            }
#endif

            if (dsi->flags & DSI_RECONINPROG) {
                LOG(log_note, logtype_afpd, "afp_over_dsi: failed reconnect");
                afp_dsi_close(obj);
                exit(0);
            }

            /* Some error on the client connection, enter disconnected state */
            if (dsi_disconnect(dsi) != 0)
                afp_dsi_die(EXITERR_CLNT);

            while (dsi->flags & DSI_DISCONNECTED)
                pause(); /* gets interrupted by SIGALARM or SIGURG tickle */
            continue; /* continue receiving until disconnect timer expires
                       * or a primary reconnect succeeds  */
        }

        if (!(dsi->flags & DSI_EXTSLEEP) && (dsi->flags & DSI_SLEEPING)) {
            LOG(log_debug, logtype_afpd, "afp_over_dsi: got data, ending normal sleep");
            dsi->flags &= ~DSI_SLEEPING;
            dsi->tickle = 0;
        }

        if (reload_request) {
            reload_request = 0;
            load_volumes(AFPobj);
        }

        /* The first SIGINT enables debugging, the next restores the config */
        if (debug_request) {
            static int debugging = 0;
            debug_request = 0;

            dircache_dump();
            uuidcache_dump();

            if (debugging) {
                if (obj->options.logconfig)
                    setuplog(obj->options.logconfig);
                else
                    setuplog("default log_note");
                debugging = 0;
            } else {
                char logstr[50];
                debugging = 1;
                sprintf(logstr, "default log_maxdebug /tmp/afpd.%u.XXXXXX", getpid());
                setuplog(logstr);
            }
        }


        dsi->flags |= DSI_DATA;
        dsi->tickle = 0;

        switch(cmd) {

        case DSIFUNC_CLOSE:
            LOG(log_debug, logtype_afpd, "DSI: close session request");
            afp_dsi_close(obj);
            LOG(log_note, logtype_afpd, "done");
            exit(0);

        case DSIFUNC_TICKLE:
            dsi->flags &= ~DSI_DATA; /* thats no data in the sense we use it in alarm_handler */
            LOG(log_debug, logtype_afpd, "DSI: client tickle");
            /* timer is not every 30 seconds anymore, so we don't get killed on the client side. */
            if ((dsi->flags & DSI_DIE))
                dsi_tickle(dsi);
            break;

        case DSIFUNC_CMD:
#ifdef AFS
            if ( writtenfork ) {
                if ( flushfork( writtenfork ) < 0 ) {
                    LOG(log_error, logtype_afpd, "main flushfork: %s", strerror(errno) );
                }
                writtenfork = NULL;
            }
#endif /* AFS */

            function = (u_char) dsi->commands[0];

            /* AFP replay cache */
            rc_idx = dsi->clientID % REPLAYCACHE_SIZE;
            LOG(log_debug, logtype_dsi, "DSI request ID: %u", dsi->clientID);

            if (replaycache[rc_idx].DSIreqID == dsi->clientID
                && replaycache[rc_idx].AFPcommand == function) {
                LOG(log_note, logtype_afpd, "AFP Replay Cache match: id: %u / cmd: %s",
                    dsi->clientID, AfpNum2name(function));
                err = replaycache[rc_idx].result;
            /* AFP replay cache end */
            } else {
                /* send off an afp command. in a couple cases, we take advantage
                 * of the fact that we're a stream-based protocol. */
                if (afp_switch[function]) {
                    dsi->datalen = DSI_DATASIZ;
                    dsi->flags |= DSI_RUNNING;

                    LOG(log_debug, logtype_afpd, "<== Start AFP command: %s", AfpNum2name(function));

                    err = (*afp_switch[function])(obj,
                                                  (char *)&dsi->commands, dsi->cmdlen,
                                                  (char *)&dsi->data, &dsi->datalen);

                    LOG(log_debug, logtype_afpd, "==> Finished AFP command: %s -> %s",
                        AfpNum2name(function), AfpErr2name(err));

                    dir_free_invalid_q();

#ifdef FORCE_UIDGID
                    /* bring everything back to old euid, egid */
                    if (obj->force_uid)
                        restore_uidgid ( &obj->uidgid );
#endif /* FORCE_UIDGID */
                    dsi->flags &= ~DSI_RUNNING;

                    /* Add result to the AFP replay cache */
                    replaycache[rc_idx].DSIreqID = dsi->clientID;
                    replaycache[rc_idx].AFPcommand = function;
                    replaycache[rc_idx].result = err;
                } else {
                    LOG(log_error, logtype_afpd, "bad function %X", function);
                    dsi->datalen = 0;
                    err = AFPERR_NOOP;
                }
            }

            /* single shot toggle that gets set by dsi_readinit. */
            if (dsi->flags & DSI_NOREPLY) {
                dsi->flags &= ~DSI_NOREPLY;
                break;
            } else if (!dsi_cmdreply(dsi, err)) {
                LOG(log_error, logtype_afpd, "dsi_cmdreply(%d): %s", dsi->socket, strerror(errno) );
                if (dsi_disconnect(dsi) != 0)
                    afp_dsi_die(EXITERR_CLNT);
            }
            break;

        case DSIFUNC_WRITE: /* FPWrite and FPAddIcon */
            function = (u_char) dsi->commands[0];
            if ( afp_switch[ function ] != NULL ) {
                dsi->datalen = DSI_DATASIZ;
                dsi->flags |= DSI_RUNNING;

                LOG(log_debug, logtype_afpd, "<== Start AFP command: %s", AfpNum2name(function));

                err = (*afp_switch[function])(obj,
                                              (char *)&dsi->commands, dsi->cmdlen,
                                              (char *)&dsi->data, &dsi->datalen);

                LOG(log_debug, logtype_afpd, "==> Finished AFP command: %s -> %s",
                    AfpNum2name(function), AfpErr2name(err));

                dsi->flags &= ~DSI_RUNNING;
#ifdef FORCE_UIDGID
            	/* bring everything back to old euid, egid */
		if (obj->force_uid)
            	    restore_uidgid ( &obj->uidgid );
#endif /* FORCE_UIDGID */
            } else {
                LOG(log_error, logtype_afpd, "(write) bad function %x", function);
                dsi->datalen = 0;
                err = AFPERR_NOOP;
            }

            if (!dsi_wrtreply(dsi, err)) {
                LOG(log_error, logtype_afpd, "dsi_wrtreply: %s", strerror(errno) );
                if (dsi_disconnect(dsi) != 0)
                    afp_dsi_die(EXITERR_CLNT);
            }
            break;

        case DSIFUNC_ATTN: /* attention replies */
            break;

            /* error. this usually implies a mismatch of some kind
             * between server and client. if things are correct,
             * we need to flush the rest of the packet if necessary. */
        default:
            LOG(log_info, logtype_afpd,"afp_dsi: spurious command %d", cmd);
            dsi_writeinit(dsi, dsi->data, DSI_DATASIZ);
            dsi_writeflush(dsi);
            break;
        }
        pending_request(dsi);

        fce_pending_events(obj);
    }

    /* error */
    afp_dsi_die(EXITERR_CLNT);
}
예제 #5
0
/* processing with map-request - only MS|NODE|MR function*/
	int 
generic_process_request(void *data, struct communication_fct * fct){
	struct db_table * table;
	struct db_node * rn = NULL;
	struct prefix p;
	int is_ddt;
	struct db_node *node = NULL;	
	int rt;
	struct pk_req_entry *pke = data;
		
	/* look for the eid */
	fct->request_get_eid(pke, &p);
	table = ms_get_db_table(ms_db,&p);
	rn = db_node_match_prefix(table, &p);
			
	fct->request_is_ddt(pke, &is_ddt);

	/* Received DDT request */
	if(is_ddt){
		/*function of {map-register-with-DDT|DDT-node}*/
		if(!rn){
			/*If the requested XEID did not match either a configured delegation or
				an authoritative XEID-prefix, then the request is dropped and a
				negative Map-Referral with action code NOT-AUTHORITATIVE is returned.
			*/	
			if(_fncs & _FNC_NODE){
				rt =  _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);
				
			}				
			return (TRUE);
		}
		node = rn;
		if( !rn->flags || !((struct mapping_flags *)rn->flags)->range){
			node = ms_get_target(rn);
		}
		
		/* existing mapping for request */	
		if (ms_node_is_type(node, _MAPP)){
			/* not referral node, it must belong to MS */			
			if( !((struct mapping_flags *)node->flags)->referral){
				/* do ms function: reply or foward to ETR */
				if(_fncs & _FNC_MS){
					if(ms_node_is_proxy_reply(node)){
						rt = _request_reply(pke, fct, node, NULL);
						
						return (TRUE);
					}
					
					cp_log(LDEBUG, "Forwarding to ETR\n");
						
					_request_referral(pke, fct, node);
					
					rt = _forward_to_etr(pke,node);	
						
					return (TRUE);
				}
				/*it not be here: it is not MS but is has normal mapping */
				return FALSE;
			}
			
			/* referral node, must belong to NODE or MR*/
			if ( _fncs & _FNC_NODE){
				/*Auth EID referral - return with map-referral*/				
				if( ((struct mapping_flags *)node->flags)->A ){					
					rt =  _request_referral(pke, fct, node);	
					return (TRUE);
				}else{
					while(node != table->top && 
							(!node->flags ||
							!((struct mapping_flags *)node->flags)->A))
						node = node->parent;			
					if(node == table->top){
						rt =  _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);					
						return TRUE;
					}
					rt =  _request_referral(pke, fct, node);
					return TRUE;
				}				
			}
		}
		else{//not exist mapping
			if ( _fncs & _FNC_MS || _fncs & _FNC_NODE){
				/* node has type */
				while (node != table->top && 
						( !node->flags || 
						!( ((struct mapping_flags *)node->flags)->range & (_EID | _GEID | _GREID)) ))
					node = node->parent;
				
				if(node == table->top){
					rt =  _request_referral_negative(pke, fct, node, &p, 0, 0, LISP_REFERRAL_NOT_AUTHORITATIVE, 0, 1);
					return TRUE;
				}else{
					switch (((struct mapping_flags *)node->flags)->range){
						case _EID: /* EID not is registered */
							if ( _fncs & _FNC_MS){
								rt =  _request_referral_negative(pke, fct, node, &p, 60, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);	
								return TRUE;
							}
							break;
						case _GEID:/* EID not assign for any ETR */
							if ( _fncs & _FNC_MS){
								/* in ieft, this case is same as _EID, but it think TTL must longer*/
								rt =  _request_referral_negative(pke, fct, node, &p, 900, 1, LISP_REFERRAL_MS_NOT_REGISTERED, 0, 1);	
								return TRUE;
							}	
							break;
						case _GREID:/* EID not delegated */
							if ( _fncs & _FNC_NODE){
								rt = _request_referral_negative(pke, fct, rn, &p, 60, 0, LISP_REFERRAL_DELEGATION_HOLE,0, 1 );		
								return TRUE;	
							}
							break;						
					}
					/*can not here or database has problem */
					return FALSE;
				}
			}
		}	
		cp_log(LDEBUG, "Not process...ignore packet\n");
		return FALSE;
	}
	/* Received non DDT request */
	else{
		/*function of {map-resolver |map-register-with-no-DDD-function} */
		node = rn;		
		if(!(rn->flags) || !((struct mapping_flags *)rn->flags)->range){
			node = ms_get_target(rn);
		}
		
		if ( ms_node_is_type(node, _MAPP)){
			/* node is MAPP, must belong to MS */
			if( !ms_node_is_referral(node)){
				if(_fncs & _FNC_MS){
					if(ms_node_is_proxy_reply(node)){
						rt = _request_reply(pke, fct, node, NULL);
																	
						return rt;
					}
					else{
						cp_log(LDEBUG, "Forwarding to ETR\n");
						
						rt = _forward_to_etr(pke,node);							
						return rt;	
					}				
				}
				return FALSE;
			}
			else{
				/* do MR function */
				if(_fncs & _FNC_MR){
					pending_request(pke, fct, node);					
					return 1;
				}
			}
		}
		else{/*node is not mapping */
			while (node != table->top && 
						( !node->flags || 
						!( ((struct mapping_flags *)node->flags)->range & (_EID | _GEID)) ))
				node = node->parent;
			if(_fncs & _FNC_MS){
				if(node == table->top)
					return FALSE;
				if ( ms_node_is_type(node,_EID))
					rt = _request_reply_negative(pke, fct, node, &p, 60, 1, 1, 0);	
				else
					rt = _request_reply_negative(pke, fct, node, &p, 900, 1, 1, 0);	
				return TRUE;					
			}
			if(_fncs & _FNC_MR){
				pending_request(pke, fct, node);					
				return TRUE;
			}
		}	
	}
	cp_log(LDEBUG, "Not process...ignore packet\n");
	return FALSE;			
}