コード例 #1
0
ファイル: exec.c プロジェクト: geechee/iraf
/* EXECNEWTASK -- Called from the EXEC instruction after all param and stdio
 * processing for the new task is complete.  Here we actually run the new task,
 * either directly in the case of a builtin function, or as a new case for
 * main()'s loop.  Do not set newtask to NULL so that run() can tell what it
 * exec'd.
 */
void
execnewtask (void)
{
	/* VMS C V2.1 cannot handle this (see below).
	 * register struct pfile *pfp;
	 */
	static	struct pfile *pfp;

	struct	param *pp;
	FILE	*fopen();

	if (newtask == NULL)
	    /* if this ever happens, i don't want to know about it. */
	    return;
	
	currentask->t_pc = pc;		/* instruction after EXEC	*/

	if (cldebug)
	    eprintf ("execnewtask: pc = %d\n", pc);

	if (newtask->t_flags & T_BUILTIN) {
	    /* set yyin in case a builtin reads someday; none do now.
	     * unlink newtask's fake param file and reset top of dictionary
	     *   to what it was before the fake param file was added; it is
	     *   still there, however, for the builtin to use. this is done
	     *   since some builtins (eg task) want to add things that are
	     *   to stay on the dictionary and the tools all start at topd.
	     * the return is back to run(); it will continue since it will
	     *   see that newtask was just a builtin.
	     * note that we do not reset pf_n, as with other fake pfiles,
	     *   as this is the way builtins get their number of arguments
	     *   (it's faster than building them a $nargs).
	     */
	    yyin = newtask->t_in = currentask->t_in;	/* inherit pipe */
	    newtask->t_out = currentask->t_out;
	    newtask->t_modep = currentask->t_modep;	/* inherit mode */

	    /* VMS C 2.1 Optimizer cannot handle this.
	     * parhead = dereference (reference (pfile, parhead)->pf_npf);
	     */
	    pfp = reference (pfile, parhead);
	    parhead = dereference (pfp->pf_npf);

	    topd = currentask->t_topd;
	    currentask = newtask;
	    newtask->t_flags |= T_RUNNING;

	    if (cldebug)
		eprintf ("execnewtask: calling new [email protected]%x\n", newtask);
	    if (cltrace)
		eprintf ("\t----- exec %s %s -----\n",
		    (newtask->t_flags & T_FOREIGN) ? "foreign" : "builtin",
		    newtask->t_ltp->lt_lname);

	    (*newtask->t_ltp->lt_f)();
	    oneof();		/* proceed as though this task saw eof	  */
	    return;
	}

	pfp = newtask->t_pfp;

	/* If the new task is a cl, we are not running in background and
	 * its t_in is stdin, it is interactive.  Note that when a package
	 * is loaded by a script task rather than interactively by the user,
	 * the t_in of the cl() in the package script task will be reading
	 * from the calling script task rather than from the original stdin
	 * (the user terminal), hence is not interactive.  If this task is
	 * flagged interactive, taskunwind() may elect to restart it on an
	 * error so save present state for restor().
	 */
	if (newtask->t_flags & T_CL) {
	    if (cldebug)
		eprintf ("execnewtask: new task is the CL\n");
	    if (cltrace)
		eprintf ("\t----- exec cl -----\n");

	    /* Call set_clio to set the command input and output streams
	     * t_in and t_out for a cl() or package_name() command.
	     */
	    set_clio (newtask);

	    /* This code is a temporary patch to allow packages to be 
	     * loaded from within scripts regardless of whether there 
	     * are enclosing brackets.  If a CL statement is executed
	     * within a script which is itself called within another
	     * script, then we will do an implicit keep before the CL.
	     */
	    if (topcs + 2*TASKSIZ <= STACKSIZ)
		if ((strcmp (newtask->t_ltp->lt_lname, "cl") == 0) ||
 		    (strcmp (newtask->t_ltp->lt_lname, "clbye") == 0))
		    if ((currentask->t_flags &  T_SCRIPT) &&
		        (prevtask->t_flags & T_SCRIPT))
			keep(prevtask);

	    /* If newtask is cleof(), close the input stream of the current
	     * task (the task whose input contained the cleof), and reopen
	     * as the null file.
	     */
	    if (newtask->t_flags & T_CLEOF) {
		if (currentask->t_in != stdin)
		    fclose (currentask->t_in);
		if (currentask != firstask)
		    currentask->t_in = fopen ("dev$null", "r");
	    }

	    if (!(firstask->t_flags & T_BATCH) &&
		 (newtask->t_in == stdin) && (newtask->t_out == stdout)) {
		newtask->t_flags |= T_INTERACTIVE;
		newtask->t_topd = topd;
		newtask->t_topos = topos;
		newtask->t_topcs = topcs;
		newtask->t_curpack = curpack;
	    }
	}

	/* Standardize the pfile.
	 * Set (or create if necessary) `$nargs', number of command line args,
	 *   based on pf_n which is set for each command line argument by
	 *   posargset, et al.
	 * If this ltask had no paramfile and we built one up from the
	 *   command line, then we need to add a `mode' param.  If it did have
	 *   a paramfile, then pfileload has already added it for us.
	 *   Point t_modep to the mode param for newtask.
	 */
	pp = paramfind (pfp, "$nargs", 0, YES);
	if (pp == NULL || (XINT)pp == ERR) {
	    char nabuf[FAKEPARAMLEN];
	    sprintf (nabuf, "$nargs,i,h,%d\n", pfp->pf_n);
	    pp = addparam (pfp, nabuf, NULL);
	    pp->p_mode |= M_FAKE;		/* never flush out $nargs */
	} else
	    pp->p_val.v_i = pfp->pf_n;

	if (pfp->pf_flags & PF_FAKE) {
	    newtask->t_modep = addparam (pfp, "mode,s,h,q\n", NULL);
	    /* pf_n will be used by paramsrch() to count positional arg
	     * matches; see it and param.h.
	     */
	    pfp->pf_n = 0;
	} else {
	    newtask->t_modep = paramfind (pfp, "mode", 0, YES);
	}

	if (newtask->t_modep == NULL)
	    cl_error (E_IERR, "no mode param for task `%s'",
		newtask->t_ltp->lt_lname);

	/* If task is being run in menu mode, call up eparam so that the user
	 * can edit/inspect the parameters.  If eparam is exited with ctrl/c
	 * do not run the task or update the pfile.  The parameter editor
	 * will make a copy of the task's pfile(s), edit it, and if necessary
	 * update the incore version created earlier by callnewtask().
	 */
	if ((taskmode(newtask) & M_MENU) || (newtask->t_flags & T_PSET)) {
	    if (epset (newtask->t_ltp->lt_lname) == ERR) {
		if (newtask->t_flags & T_PSET)
		    cl_error (E_UERR, "parameter file not updated");
		else
		    cl_error (E_UERR, "menu mode task execution aborted");
	    }
	}

	/* Set up bascode so new task has a good place to start building
	 * code.  See how the pc is set up before each call to the parser in
	 * main() loop.
	 */
	newtask->t_bascode = topos + 1;

	/* Set up io paths.  If the new task is cl(), it's command input
	 * and output streams are connected to those of the task which
	 * called currentask.  If the currentask is the firstask, there
	 * was no caller (no prevtask), so we must watch out for that.
	 * In the case of a script, commands are read from the script.
	 * In the case of a process, commands are read from the process.
	 */
	if (newtask->t_flags & T_PSET) {
	    newtask->t_in = fopen ("dev$null", "r");
	    newtask->t_out = newtask->t_stdout;

	} else if (newtask->t_flags & T_SCRIPT) {
	    if (cltrace)
		eprintf ("\t----- exec script %s (%s) -----\n",
		    newtask->t_ltp->lt_lname, newtask->t_ltp->lt_pname);

	    newtask->t_in = fopen (newtask->t_ltp->lt_pname, "r");
	    if (newtask->t_in == NULL)
		cl_error (E_UERR|E_P, "can not open script file `%s'",
		    newtask->t_ltp->lt_pname);
	    newtask->t_out = newtask->t_stdout;

	} else if (newtask->t_flags & T_CL) {
	    /* The command streams t_in and t_out have already been
	     * set up above by set_clio() in the test for T_INTERACTIVE.
	     */
	    /* Do nothing */

	} else {
	    char    startup_msg[SZ_STARTUPMSG+1];
	    int     timeit;

	    /* Connect to an executable process.
	     */
	    mk_startupmsg (newtask, startup_msg, SZ_STARTUPMSG);
	    timeit = (newtask->t_flags & T_TIMEIT) != 0;
	    if (cltrace)
		eprintf ("\t----- exec external task %s -----\n",
		    newtask->t_ltp->lt_lname);
	    newtask->t_pid = pr_connect (
		findexe (newtask->t_ltp->lt_pkp, newtask->t_ltp->lt_pname),
		startup_msg,
		&newtask->t_in, &newtask->t_out,
		newtask->t_stdin, newtask->t_stdout, newtask->t_stderr,
		newtask->t_stdgraph, newtask->t_stdimage, newtask->t_stdplot,
		timeit);
	}

	yyin = newtask->t_in;	/* set the input for the parser	*/

	/* Tell parser what to expect.
	 */
	parse_state = PARSE_FREE;
	if (newtask->t_flags & T_SCRIPT) {
	    proc_script = (newtask->t_flags & T_PSET) ? NO : procscript(yyin);

	    if (proc_script) {
		parse_state = PARSE_BODY;
		/* Skip to the BEGIN statement */
		newtask->t_scriptln = skip_to (yyin, "begin");
		if (newtask->t_scriptln == ERR)
		    cl_error (E_UERR, "No BEGIN statement in procedure script");

		/* Reset pointer here.
		 */
		proc_script = NO;
	    }
	}

	/* Log a start message for script and executable tasks.
	 */
	if (keeplog() && log_trace())
	    if (newtask->t_flags & T_SCRIPT || newtask->t_pid != -1) {
	    	char  logmsg[SZ_LINE];
	    	sprintf (logmsg, "Start (%s)", newtask->t_ltp->lt_pname);
	    	putlog (newtask, logmsg);
	    }

	newtask->t_flags |= T_RUNNING;
	currentask = newtask;	/* continue as new the new task; at last. */

	if (cldebug)
	    eprintf ("Returning from execnewtask.yyin, ct_in, nt_in:%d %d %d\n",
		yyin, currentask->t_in, newtask->t_in);
}
コード例 #2
0
ファイル: tps65217.c プロジェクト: junzhe/minix_pandaboard_es
int
main(int argc, char *argv[])
{
	int r;
	endpoint_t user, caller;
	message m;
	int ipc_status;

	env_setargs(argc, argv);

	r = i2cdriver_env_parse(&bus, &address, valid_addrs);
	if (r < 0) {
		log_warn(&log, "Expecting -args 'bus=X address=0xYY'\n");
		log_warn(&log, "Example -args 'bus=1 address=0x24'\n");
		return EXIT_FAILURE;
	} else if (r > 0) {
		log_warn(&log,
		    "Invalid slave address for device, expecting 0x24\n");
		return EXIT_FAILURE;
	}

	sef_local_startup();

	while (TRUE) {

		/* Receive Message */
		r = sef_receive_status(ANY, &m, &ipc_status);
		if (r != OK) {
			log_warn(&log, "sef_receive_status() failed\n");
			continue;
		}

		log_trace(&log, "Got a message 0x%x from 0x%x\n", m.m_type,
		    m.m_source);

		if (is_ipc_notify(ipc_status)) {

			switch (m.m_source) {

			case DS_PROC_NR:
				/* bus driver changed state, update endpoint */
				i2cdriver_handle_bus_update(&bus_endpoint, bus,
				    address);
				break;
			case HARDWARE:
				intr_handler();
				break;
			default:
				break;
			}

			/* Do not reply to notifications. */
			continue;
		}

		caller = m.m_source;
		user = m.USER_ENDPT;

		/*
		 * Handle Message
		 *
		 * So far this driver only deals with notifications
		 * so it always replies to non-notifications with EINVAL.
		 */

		/* Send Reply */
		m.m_type = TASK_REPLY;
		m.REP_ENDPT = user;
		m.REP_STATUS = EINVAL;

		r = sendnb(caller, &m);
		if (r != OK) {
			log_warn(&log, "sendnb() failed\n");
			continue;
		}
	}

	return 0;
}
コード例 #3
0
ファイル: backend_sync.cpp プロジェクト: CowLeo/ssdb
int BackendSync::Client::copy(){
	if(this->iter == NULL){
		log_info("new iterator, last_key: '%s'", hexmem(last_key.data(), last_key.size()).c_str());
		std::string key = this->last_key;
		if(this->last_key.empty()){
			key.push_back(DataType::MIN_PREFIX);
		}
		this->iter = backend->ssdb->iterator(key, "", -1);
		log_info("iterator created, last_key: '%s'", hexmem(last_key.data(), last_key.size()).c_str());
	}
	int ret = 0;
	int iterate_count = 0;
	int64_t stime = time_ms();
	while(true){
		// Prevent copy() from blocking too long
		if(++iterate_count > 1000 || link->output->size() > 2 * 1024 * 1024){
			break;
		}
		
		if(!iter->next()){
			goto copy_end;
		}
		Bytes key = iter->key();
		if(key.size() == 0){
			continue;
		}
		// finish copying all valid data types
		if(key.data()[0] > DataType::MAX_PREFIX){
			goto copy_end;
		}
		Bytes val = iter->val();
		this->last_key = key.String();
			
		char cmd = 0;
		char data_type = key.data()[0];
		if(data_type == DataType::KV){
			cmd = BinlogCommand::KSET;
		}else if(data_type == DataType::HASH){
			cmd = BinlogCommand::HSET;
		}else if(data_type == DataType::ZSET){
			cmd = BinlogCommand::ZSET;
		}else if(data_type == DataType::QUEUE){
			cmd = BinlogCommand::QPUSH_BACK;
		}else{
			continue;
		}
		ret++;
		
		Binlog log(this->last_seq, BinlogType::COPY, cmd, slice(key));
		log_trace("fd: %d, %s", link->fd(), log.dumps().c_str());
		link->send(log.repr(), val);
		
		if(time_ms() - stime > 3000){
			log_info("copy blocks too long, flush");
			break;
		}
	}
	return ret;

copy_end:		
	log_info("%s:%d fd: %d, copy end", link->remote_ip, link->remote_port, link->fd());
	this->status = Client::SYNC;
	delete this->iter;
	this->iter = NULL;

	Binlog log(this->last_seq, BinlogType::COPY, BinlogCommand::END, "");
	log_trace("fd: %d, %s", link->fd(), log.dumps().c_str());
	link->send(log.repr(), "copy_end");
	return 1;
}
コード例 #4
0
ファイル: session.c プロジェクト: 12019/svn.gov.pt
CK_RV C_Login(CK_SESSION_HANDLE hSession,  /* the session's handle */
              CK_USER_TYPE      userType,  /* the user type */
              CK_CHAR_PTR       pPin,      /* the user's PIN */
              CK_ULONG          ulPinLen)  /* the length of the PIN */
{
   int ret;
   P11_SESSION *pSession = NULL;
   P11_SLOT *pSlot = NULL;
   CK_TOKEN_INFO tokeninfo;
   	printf("\n********************\n");
	printf("CK_RV C_Login called\n");

//return(CKR_OK);
log_trace(WHERE, "I: enter");
   ret = p11_lock();
//printf("p11_lock returns: %s\n",!ret ? "OK" : "ERROR");
if (ret != CKR_OK)
{
	log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
	//printf("LOCK failled!\n");
   	//printf("\n********************\n");
   return ret;
}

if (isAcroread())
{
	return CKR_OK;
}

memset(&tokeninfo, 0, sizeof(CK_TOKEN_INFO));

log_trace(WHERE, "S: Login (session %d)", hSession);

	printf("Login (session %d)\n",hSession);

   if (userType != CKU_USER && userType != CKU_SO)
      {
      ret = CKR_USER_TYPE_INVALID;
	//printf("TIPO DE UTILIZADOR INVALIDO\n");
      goto cleanup;
      }
   ret = p11_get_session(hSession, &pSession);
   if (ret)
      {
      //log_trace(WHERE, "E: Invalid session handle (%d)", hSession);
	//printf("INVALID SESSION HANDLE - %d -\n",hSession);
      goto cleanup;
      }

   pSlot = p11_get_slot(pSession->hslot);
   if (pSlot == NULL)
      {
      log_trace(WHERE, "E: Slot not found for session %d", hSession);
      ret = CKR_SESSION_HANDLE_INVALID;
	//printf("SLOT NOT FOUND FOR SESSION\n");
      goto cleanup;
      }

   if (pSlot->login_type >= 0)
      {
	  // Needed for Acrobat, in case you want to sign with a 2nd card
      ret = CKR_OK; //CKR_USER_ALREADY_LOGGED_IN;
	//printf("Acrobat caso especial!");
      goto cleanup;
      }

/*   ret = cal_get_token_info(pSlot, &tokeninfo);
   if (ret != CKR_OK)
      {
      log_trace(WHERE, "E: could not find tokeninfo for slot %d", pSession->hslot);
      goto cleanup;
      }

    if ( !(tokeninfo.flags & CKF_USER_PIN_INITIALIZED) )
      {
      ret = CKR_USER_PIN_NOT_INITIALIZED;
      goto cleanup;
      }*/

   ret = cal_logon(pSession->hslot, ulPinLen, pPin, 0);
   if (ret == CKR_OK){
      pSlot->login_type = userType;
      //printf("Tudo OK! - ret = %d\n",ret);
   }
cleanup:
   p11_unlock();
   log_trace(WHERE, "I: leave, ret = %i",ret);
   	//printf("RET = %d\n",ret);
	//printf("\n********************\n");
	
   return ret;
}
コード例 #5
0
ファイル: p11.c プロジェクト: 12019/svn.gov.pt
int p11_add_slot_object(P11_SLOT *pSlot, CK_ATTRIBUTE_PTR pTemplate, CK_ULONG ulCount, CK_BBOOL bToken, CK_ULONG type, CK_ULONG id,  CK_BBOOL bPrivate, CK_ULONG *phObject)
{
    int ret = CKR_OK;
    P11_OBJECT *pObject = NULL;
//unsigned int hObject = 0;

    *phObject = 0;

    ret = p11_new_slot_object(pSlot, phObject);
    if ((ret != 0) || (*phObject == 0))
    {
        log_trace(WHERE, "E: could not add new slot object during init of objects");
        return(ret);
    }

    pObject = p11_get_slot_object(pSlot, *phObject);

//add room for attributes as in template
    pObject->pAttr = (CK_ATTRIBUTE_PTR) malloc(ulCount * sizeof(CK_ATTRIBUTE));
    if (pObject->pAttr == NULL)
    {
        log_trace(WHERE, "E: alloc error for attribute");
        return (CKR_HOST_MEMORY);
    }

//set the size of the object attributes
    pObject->count = ulCount;

//copy the template to the new object
    ret = p11_copy_object(pTemplate, ulCount, pObject->pAttr);
    if (ret)
    {
        log_trace(WHERE, "E: p11_copy_object() returned %d", ret);
        goto cleanup;
    }

//CKA_TOKEN
    ret = p11_set_attribute_value(pObject->pAttr, ulCount, CKA_TOKEN, (CK_VOID_PTR) &bToken, sizeof(CK_BBOOL));
    if (ret)
    {
        log_trace(WHERE, "E: p11_set_attribute_value(CKA_TOKEN) returned %d", ret);
        goto cleanup;
    }

//CKA_CLASS
    ret = p11_set_attribute_value(pObject->pAttr, ulCount, CKA_CLASS, (CK_VOID_PTR) &type, sizeof(CK_ULONG));
    if (ret)
    {
        log_trace(WHERE, "E: p11_set_attribute_value(CKA_CLASS) returned %d", ret);
        goto cleanup;
    }

//CKA_ID
    ret = p11_set_attribute_value(pObject->pAttr, ulCount, CKA_ID, (CK_VOID_PTR) &id, sizeof(CK_ULONG));
    if (ret)
    {
        log_trace(WHERE, "E: p11_set_attribute_value(CKA_ID) returned %d", ret);
        goto cleanup;
    }

//CKA_PRIVATE
    ret = p11_set_attribute_value(pObject->pAttr, ulCount, CKA_PRIVATE, (CK_VOID_PTR) &bPrivate, sizeof(CK_BBOOL));
    if (ret)
    {
        log_trace(WHERE, "E: p11_set_attribute_value(CKA_PRIVATE) returned %d", ret);
        goto cleanup;
    }

cleanup:

    return (ret);
}
コード例 #6
0
ファイル: SessionStore.c プロジェクト: rsms/smisk
void smisk_SessionStore_dealloc(smisk_SessionStore *self) {
  log_trace("ENTER");
  Py_DECREF(self->name);
  self->ob_type->tp_free((PyObject*)self);
}
コード例 #7
0
ファイル: SessionStore.c プロジェクト: rsms/smisk
PyObject *smisk_SessionStore_destroy(smisk_SessionStore *self, PyObject *session_id) {
  log_trace("ENTER");
  PyErr_SetString(PyExc_NotImplementedError, "destroy");
  return NULL;
}
コード例 #8
0
ファイル: module_dns.c プロジェクト: Fale/zmap
static uint16_t get_name_helper(const char* data, uint16_t data_len, 
		const char* payload, uint16_t payload_len, char* name, 
		uint16_t name_len, uint16_t recursion_level)
{
	log_trace("dns", "_get_name_helper IN, datalen: %d namelen: %d recusion: %d", 
			data_len, name_len, recursion_level);

	if (data_len == 0 || name_len == 0 || payload_len == 0) {
		log_trace("dns", "_get_name_helper OUT, err. 0 length field. datalen %d namelen %d payloadlen %d", 
				data_len, name_len, payload_len);
		return 0;
	}

	if (recursion_level > MAX_LABEL_RECURSION) {
		log_trace("dns", "_get_name_helper OUT. ERR, MAX RECUSION");
		return 0;
	}

	uint16_t bytes_consumed = 0;

	// The start of data is either a sequence of labels or a ptr.
	while(data_len > 0) { 

		uint8_t byte = data[0];
   
		// Is this a pointer?
		if (byte >= 0xc0) {
		 
			log_trace("dns", "_get_name_helper, ptr encountered");
		  
			// Do we have enough bytes to check ahead?
			if (data_len < 2) {
				log_trace("dns", "_get_name_helper OUT. ptr byte encountered. No offset. ERR.");
				return 0;
			}

			// No. ntohs isn't needed here. It's because of
			// the upper 2 bits indicating a pointer.
			uint16_t offset = ((byte & 0x03) << 8) | (uint8_t)data[1];

			log_trace("dns", "_get_name_helper. ptr offset 0x%x", offset);

			if (offset >= payload_len) { 
				log_trace("dns", "_get_name_helper OUT. offset exceeded payload len %d ERR", 
						payload_len);
				return 0;
			}

			// We need to add a dot if we are:
			// -- Not first level recursion.
			// -- have consumed bytes
			if (recursion_level > 0 || bytes_consumed > 0) {

				if (name_len < 1) {
					log_warn("dns", "Exceeded static name field allocation.");
					return 0;
				}
			
				name[0] = '.';
				name++;
				name_len--;
			}

			uint16_t rec_bytes_consumed = get_name_helper(payload + offset, 
					payload_len - offset, payload, payload_len, name, name_len, 
					recursion_level + 1);

			// We are done so don't bother to increment the pointers.
			if (rec_bytes_consumed == 0) {
				log_trace("dns", "_get_name_helper OUT. rec level %d failed", 
						recursion_level);
				return 0;
			} else {
				bytes_consumed += 2;
				log_trace("dns", "_get_name_helper OUT. rec level %d success. %d rec bytes consumed. %d bytes consumed.", 
						recursion_level, rec_bytes_consumed, bytes_consumed);
				return bytes_consumed;
			}

		} else if (byte == '\0') {

			// don't bother with pointer incrementation. We're done.
			bytes_consumed += 1;
			log_trace("dns", "_get_name_helper OUT. rec level %d success. %d bytes consumed.", 
					recursion_level, bytes_consumed);
			return bytes_consumed; 
		
		} else {

			log_trace("dns", "_get_name_helper, segment 0x%hx encountered", 
					byte);

			// We've now consumed a byte.
			++data;
			--data_len;
			// Mark byte consumed after we check for first iteration.

			// Do we have enough data left (must have null byte too)?
			if ((byte+1) > data_len) {
				log_trace("dns", "_get_name_helper OUT. ERR. Not enough data for segment %hd"); 
				return 0;
			}	

			// If we've consumed any bytes and are in a label, we're in a 
			// label chain. We need to add a dot.
			if (bytes_consumed > 0) { 

				if (name_len < 1) {
					log_warn("dns", "Exceeded static name field allocation.");
					return 0;
				}
			
				name[0] = '.';
				name++;
				name_len--;
			}

			// Now we've consumed a byte.
			++bytes_consumed;

			// Did we run out of our arbitrary buffer?
			if (byte > name_len) {
				log_warn("dns", "Exceeded static name field allocation.");
				return 0;
			}

			assert(data_len > 0);

			memcpy(name, data, byte);
	
			name += byte;
			name_len -= byte;
	
			data_len -= byte;
			data += byte;
			bytes_consumed += byte;
 
			// Handled in the byte+1 check above.
			assert(data_len > 0);
		}
	}

	// We should never get here.
	// For each byte we either have:
	// -- a ptr, which terminates
	// -- a null byte, which terminates
	// -- a segment length which either terminates or ensures we keep looping

	assert(0);
	return 0;
}
コード例 #9
0
ファイル: module_dns.c プロジェクト: Fale/zmap
static bool process_response_answer(char **data, uint16_t* data_len, 
		const char* payload, uint16_t payload_len, fieldset_t* list)
{	
	log_trace("dns", "call to process_response_answer, data_len: %d", *data_len);
	// Payload is the start of the DNS packet, including header
	// data is handle to the start of this RR
	// data_len is a pointer to the how much total data we have to work with.
	// This is awful. I'm bad and should feel bad.
	uint16_t bytes_consumed = 0;

	char* answer_name = get_name(*data, *data_len, payload, payload_len,  
			&bytes_consumed);

	// Error.
	if (answer_name == NULL) {
		return 1;
	}

	assert(bytes_consumed > 0);

	if ( (bytes_consumed + sizeof(dns_answer_tail)) > *data_len) {
		free(answer_name);
		return 1;
	}

	dns_answer_tail* tail = (dns_answer_tail*)(*data + bytes_consumed);

	uint16_t type = ntohs(tail->type);
	uint16_t class = ntohs(tail->class);
	uint32_t ttl = ntohl(tail->ttl);
	uint16_t rdlength = ntohs(tail->rdlength);
	char* rdata = tail->rdata;

	if ((rdlength + bytes_consumed + sizeof(dns_answer_tail)) > *data_len) {
		free(answer_name);
		return 1;
	}

	// Build our new question fieldset
	fieldset_t *afs = fs_new_fieldset(); 
	fs_add_unsafe_string(afs, "name", answer_name, 1);
	fs_add_uint64(afs, "type", type);
	if (type > MAX_QTYPE || qtype_qtype_to_strid[type] == BAD_QTYPE_VAL) {
		fs_add_string(afs, "type_str", (char*) BAD_QTYPE_STR, 0);
	} else {
		// I've written worse things than this 3rd arg. But I want to be fast.
		fs_add_string(afs, "type_str", 
				(char*)qtype_strs[qtype_qtype_to_strid[type]], 0);
	}
	fs_add_uint64(afs, "class", class);
	fs_add_uint64(afs, "ttl", ttl);
	fs_add_uint64(afs, "rdlength", rdlength);
	
	// XXX Fill this out for the other types we care about.
	if (type == DNS_QTYPE_NS || type == DNS_QTYPE_CNAME) {

		uint16_t rdata_bytes_consumed = 0;
		char* rdata_name = get_name(rdata, rdlength, payload, payload_len,	
				&rdata_bytes_consumed);

		if (rdata_name == NULL) {
			fs_add_uint64(afs, "rdata_is_parsed", 0);
			fs_add_binary(afs, "rdata", rdlength, rdata, 0);
		} else {
			fs_add_uint64(afs, "rdata_is_parsed", 1);
			fs_add_unsafe_string(afs, "rdata", rdata_name, 1);
		}

	 } else if (type == DNS_QTYPE_MX) {

		uint16_t rdata_bytes_consumed = 0;

		if (rdlength <= 4) {
			fs_add_uint64(afs, "rdata_is_parsed", 0);
			fs_add_binary(afs, "rdata", rdlength, rdata, 0);
		} else {

			char* rdata_name = get_name(rdata + 2, rdlength-2, payload, 
					payload_len, &rdata_bytes_consumed);

			if (rdata_name == NULL) {
				fs_add_uint64(afs, "rdata_is_parsed", 0);
				fs_add_binary(afs, "rdata", rdlength, rdata, 0);
			} else {
		   
				// (largest value 16bit) + " " + answer + null 
				char* rdata_with_pref = xmalloc(5 + 1 + strlen(rdata_name) + 1);
				
				uint8_t num_printed = snprintf(rdata_with_pref, 6, "%hu ", 
						ntohs( *(uint16_t*)rdata));
				memcpy(rdata_with_pref + num_printed, rdata_name, 
						strlen(rdata_name));

				fs_add_uint64(afs, "rdata_is_parsed", 1);
				fs_add_unsafe_string(afs, "rdata", rdata_with_pref, 1);
			}
		}
	} else if (type == DNS_QTYPE_TXT) {

		if (rdlength >= 1 && (rdlength - 1) != *(uint8_t*)rdata ) {
			log_warn("dns", "TXT record with wrong TXT len. Not processing.");
			fs_add_uint64(afs, "rdata_is_parsed", 0);
			fs_add_binary(afs, "rdata", rdlength, rdata, 0);
		} else {
			fs_add_uint64(afs, "rdata_is_parsed", 1);
			char* txt = xmalloc(rdlength);
			memcpy(txt, rdata + 1, rdlength-1);
			fs_add_unsafe_string(afs, "rdata", txt, 1);
		}
	} else if (type == DNS_QTYPE_A) {

		if (rdlength != 4) {
			log_warn("dns", "A record with IP of length %d. Not processing.", 
					rdlength);
			fs_add_uint64(afs, "rdata_is_parsed", 0);
			fs_add_binary(afs, "rdata", rdlength, rdata, 0);
		} else {
			fs_add_uint64(afs, "rdata_is_parsed", 1);
			char* addr = strdup(inet_ntoa( *(struct in_addr*)rdata ));
			fs_add_unsafe_string(afs, "rdata", addr, 1);
		}
	} else if (type == DNS_QTYPE_AAAA) {

		if (rdlength != 16) {
			log_warn("dns", "AAAA record with IP of length %d. Not processing.",
					rdlength);
			fs_add_uint64(afs, "rdata_is_parsed", 0);
			fs_add_binary(afs, "rdata", rdlength, rdata, 0);
		} else {
			fs_add_uint64(afs, "rdata_is_parsed", 1);
			char* ipv6_str = xmalloc(INET6_ADDRSTRLEN);

			inet_ntop(AF_INET6, (struct sockaddr_in6*)rdata, 
					ipv6_str,INET6_ADDRSTRLEN);

			fs_add_unsafe_string(afs, "rdata", ipv6_str, 1);
		}
	} else {
		fs_add_uint64(afs, "rdata_is_parsed", 0);
		fs_add_binary(afs, "rdata", rdlength, rdata, 0);
	}

	// Now we're adding the new fs to the list.
	fs_add_fieldset(list, NULL, afs);

	// Now update the pointers.
	*data = *data + bytes_consumed + sizeof(dns_answer_tail) + rdlength;
	*data_len = *data_len - bytes_consumed - sizeof(dns_answer_tail) - rdlength;

	log_trace("dns", "return success from process_response_answer, data_len: %d", 
			*data_len);

	return 0;
}
コード例 #10
0
ファイル: Connection.cpp プロジェクト: 3Nigma/frayon
bool Connection::readHandshake()
{
    log_trace("Connection::readHandshake");

    std::streambuf* sb = _ios->rdbuf();
    if( ! sb)
        return true;

    _maxImport = sb->in_avail();
    _wantRead = false;
    _isReading = true;
    OSStatus status = SSLHandshake(_context);
    _isReading = false;

    log_debug("SSLHandshake returns " << status);
    
    if( status == noErr )
    {
        log_debug("SSL handshake completed");
        _connected = true;
        return false;
    }

#ifdef PT_IOS
    if(status == errSSLPeerAuthCompleted)
#else
    if(status == errSSLServerAuthCompleted)
#endif
    {
        log_debug("authenticating peer");

        if( _ctx->verifyMode() != NoVerify )
        {
            log_debug("evaluating trust");
            
            SecTrustRef trust = NULL;
            SSLCopyPeerTrust(_context, &trust);

            CFArrayRef caArr = _ctx->impl()->caCertificates();
            SecTrustSetAnchorCertificates(trust, caArr);
            SecTrustSetAnchorCertificatesOnly(trust, true);

            SecTrustResultType result;
            OSStatus evalErr = SecTrustEvaluate(trust, &result);
            if(evalErr)
                throw HandshakeFailed("SSL handshake failed");
        
            CFIndex count = SecTrustGetCertificateCount(trust);
            log_debug("SecTrustEvaluate: " << result << " certs: " << count);
            
            if(trust)
                CFRelease(trust);
            
            // if peer presented no certificate, SecTrustGetCertificateCount
            // should return 0. If we require one because AlwaysVerify is
            // set, the handshake is considered to be failed
            if(_ctx->verifyMode() == AlwaysVerify && count == 0)
                throw HandshakeFailed("SSL handshake failed");

            if( (result != kSecTrustResultProceed) && 
                (result != kSecTrustResultUnspecified) )
                throw HandshakeFailed("SSL handshake failed");

            log_debug("authentication successful");
        }

        return readHandshake();
    }
    
    if( status != errSSLWouldBlock )
    {
        throw HandshakeFailed("SSL handshake failed");
    }

    return _wantRead;
}
コード例 #11
0
ファイル: server.cpp プロジェクト: qcghdy/icomet
static void on_psub_disconnect(struct evhttp_connection *evcon, void *arg){
	log_trace("presence subscriber disconnected");
	PresenceSubscriber *psub = (PresenceSubscriber *)arg;
	Server *serv = psub->serv;
	serv->psub_end(psub);
}
コード例 #12
0
ファイル: backend_sync.cpp プロジェクト: kingxsp/ssdb
int BackendSync::Client::sync(SyncLogQueue *logs){
	Buffer *output = link->output;

	uint64_t expect_seq = this->last_seq + 1;
	Synclog log;
	int ret;
	if(this->status == Client::DUMP && this->last_seq == 0){
		ret = logs->find_last(&log);
	}else{
		ret = logs->find(expect_seq, &log);
	}
	if(ret == 0){
		return 0;
	}
	/*
	log_trace("fd: %d, seq: %llu, key: %s",
		link->fd(),
		log.seq(),
		hexmem(log.key().data(), log.key().size()).c_str());
	*/
	
	// writes that are out of dumped range will be discarded.
	if(this->iter && log.key() > this->last_key){
		// update last_seq
		this->last_seq = log.seq();

		log_trace("fd: %d, seq: %llu, drop: %s, last_key: %s",
			link->fd(),
			log.seq(),
			hexmem(log.key().data(), log.key().size()).c_str(),
			hexmem(this->last_key.data(), this->last_key.size()).c_str());
		return 1;
	}

	if(this->last_seq != 0 && log.seq() != expect_seq){
		log_warn("fd: %d, OUT_OF_SYNC! seq: %llu, last_seq: %llu",
			link->fd(),
			log.seq(),
			expect_seq
			);
		this->status = Client::OUT_OF_SYNC;
		return 1;
	}
	
	// update last_seq
	this->last_seq = log.seq();

	char seq_buf[20];
	snprintf(seq_buf, sizeof(seq_buf), "%llu", log.seq());
	char log_type = log.type();
		
	// a synclog from a mirror server will not be send to another mirror server
	if(this->is_mirror && (log_type == Synclog::MIRROR_SET || log_type == Synclog::MIRROR_DEL)){
		if(this->last_seq - this->last_noop_seq >= logs->total/2){
			this->last_noop_seq = this->last_seq;
				
			log_trace("fd: %d, sync noop %llu",
				link->fd(),
				log.seq());

			output->append_record("noop");
			output->append_record(seq_buf);
			output->append('\n');
		}
	}else if(log_type == Synclog::SET || log_type == Synclog::MIRROR_SET){
		std::string val;
		int ret = backend->ssdb->raw_get(log.key(), &val);
		if(ret == -1){
			log_error("raw_get error!");
		}else if(ret == 0){
			log_trace("skip not found: %s", hexmem(log.key().data(), log.key().size()).c_str());
			// not found, ignore
		}else{
			log_trace("fd: %d, sync_set %llu %s",
				link->fd(),
				log.seq(),
				hexmem(log.key().data(), log.key().size()).c_str());

			output->append_record("sync_set");
			output->append_record(seq_buf);
			output->append_record(log.key());
			output->append_record(val);
			output->append('\n');
		}
	}else if(log_type == Synclog::DEL || log_type == Synclog::MIRROR_DEL){
		log_trace("fd: %d, sync_del %llu %s",
			link->fd(),
			log.seq(),
			hexmem(log.key().data(), log.key().size()).c_str());

		output->append_record("sync_del");
		output->append_record(seq_buf);
		output->append_record(log.key());
		output->append('\n');
	}else{
		log_error("unknown sync log type: %d", log.type());
	}
	return 1;
}
コード例 #13
0
ファイル: gmParamVector.cpp プロジェクト: GraphMIC/GraphMIC
        Vector::Vector(const QString& name, QStringList labels, double x, double y, double z, double w) : Base(ComponentType, name), m_labels(labels), m_values{ {x,y,z,w} }
        {
            this->m_output = nullptr;

            log_trace(Log::New, this);
        }
コード例 #14
0
ファイル: exec.c プロジェクト: geechee/iraf
/* IOFINISH -- Flush out and wrap up all pending io for given task.
 *   Called when the task is dying and it wants to close all files it opened.
 *   This includes a pipe if it used one, a file if it was a script and io
 *   redirections as indicated by the T_MYXXX flags.  The T_MYXXX flags are
 *   set only when the redirections were done for this task, ie, they were
 *   not simply inherited.
 * Just as a fail-safe measure, always check that a real stdio file is
 *   not being closed.
 * Don't call error() because in trying to restor to an interactive task
 *   it might call us again and cause an inf. loop.
 */
void
iofinish (
  register struct task *tp
)
{
	register FILE *fp;
	int	flags;

	flags = tp->t_flags;

	/* Make sure we do not close files more than once.
	 */
	if (flags & T_RUNNING)
	    tp->t_flags &= ~T_RUNNING;
	else
	    return;

	if (cldebug)
	    eprintf ("flushing io for task `%s'\n", tp->t_ltp->lt_lname);

	if (flags & T_MYIN) {
	    fp = tp->t_stdin;
	    if (fp != stdin)
		fclose (fp);
	}
	if (flags & T_MYOUT) {
	    fflush (fp = tp->t_stdout);
	    if (fp != stdout)
		fclose (fp);
	}
	if (flags & T_MYERR) {
	    fflush (fp = tp->t_stderr);
	    if (fp != stderr)
		fclose (fp);
	}

	/* Close any redirected graphics output streams.
	 */
	if (flags & (T_MYSTDGRAPH|T_MYSTDIMAGE|T_MYSTDPLOT)) {
	    if (flags & T_MYSTDGRAPH)
		if (tp->t_stdgraph != tp->t_stdimage &&
		    tp->t_stdgraph != tp->t_stdplot)
		    fclose (tp->t_stdgraph);
	    if (flags & T_MYSTDIMAGE)
		if (tp->t_stdimage != tp->t_stdplot)
		    fclose (tp->t_stdimage);
	    if (flags & T_MYSTDPLOT)
		fclose (tp->t_stdplot);
	}

	/* If task i/o is redirected to a subprocess send the done message.
	 */
	if (flags & T_IPCIO)
	    fputs (IPCDONEMSG, tp->t_out);
	fflush (tp->t_out);

	/* Close files only for script task, not for a cl, a builtin, or
	 * a process.  Do call disconnect if the task lives in a process.
	 */
	if (flags & T_SCRIPT) {
	    fp = tp->t_in;
	    if (fp != stdin)
		fclose (fp);
	} else if (flags & (T_CL|T_BUILTIN)) {
	    ;
	} else if (tp->t_pid != -1)
	    pr_disconnect (tp->t_pid);

	/* Log a stop message for script and executable tasks.
	 */
	if (keeplog() && log_trace())
	    if (tp->t_flags & T_SCRIPT || tp->t_pid != -1)
	    	putlog (tp, "Stop");
}
コード例 #15
0
ファイル: SessionStore.c プロジェクト: rsms/smisk
int smisk_SessionStore_register_types(PyObject *module) {
  log_trace("ENTER");
  if (PyType_Ready(&smisk_SessionStoreType) == 0)
    return PyModule_AddObject(module, "SessionStore", (PyObject *)&smisk_SessionStoreType);
  return -1;
}
コード例 #16
0
ファイル: general.c プロジェクト: dagwieers/eid-mw
CK_RV C_GetSlotList(CK_BBOOL       tokenPresent,  /* only slots with token present */
	CK_SLOT_ID_PTR pSlotList,     /* receives the array of slot IDs */
	CK_ULONG_PTR   pulCount)      /* receives the number of slots */
{

	P11_SLOT *pSlot;
	CK_RV ret = CKR_OK;
	int h;
	CK_ULONG c = 0; 
	static int l=0;

	log_trace(WHERE, "I: enter");

	if (p11_get_init() != BEIDP11_INITIALIZED)
	{
		log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}

	ret = p11_lock();
	log_trace(WHERE, "I: p11_lock() acquiered");
	if (ret != CKR_OK)
	{
		log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
		return (ret);
	}

	if (++l<LOG_MAX_REC)
		log_trace(WHERE, "S: C_GetSlotList()");

	if (pulCount == NULL_PTR)
	{
		ret = CKR_ARGUMENTS_BAD;
		goto cleanup;
	}

#ifdef PKCS11_V2_20
	if(pSlotList == NULL){
		ret = cal_refresh_readers();
	}
#endif
	//init slots allready done
	//update info on tokens in slot, could be removed if thread keeps track of these token states
	//BUG in Adobe Acrobat reader: adobe asks for slots with pSlotList = NULL, so only nr of slots will be returned. This is ok.
	//a second time Adobe calls this, pSlotList still is NULL, so the array with SlotIDs cannot be returned, again, nr of slots is returned.
	//Adobe just assumes that the first slot has ID=0 !!! and uses this ID=0 for all further actions.
	//to overcome this problem, we start our SlotIDs from 0 and not 1 !!!

	log_trace(WHERE, "I: h=0");
	//Do not show the virtual reader (used to capture the reader connect events)
	//for (h=0; h < (p11_get_nreaders()-1); h++)
	for (h=0; h < p11_get_nreaders(); h++)
	{
		log_trace(WHERE, "I: h=%i",h);
		pSlot = p11_get_slot(h);

		if (l < LOG_MAX_REC) 
			log_trace(WHERE, "I: slot[%d]: %s", h, pSlot->name);

		if (tokenPresent == CK_TRUE)
		{
			int pPresent = 0;
			ret = cal_token_present(h, &pPresent);
			if(ret != CKR_OK && ret != CKR_TOKEN_NOT_RECOGNIZED)
			{
				goto cleanup;
			}
			if (pPresent)
			{
				log_trace(WHERE, "I: cal_token_present");
				c++;
				if ((pSlotList != NULL_PTR) && (c <= *pulCount) )
					pSlotList[c-1] =  h;
			}
			continue;
		}
		else
		{
			//get all slots
			c++;
			if ((pSlotList != NULL_PTR) && (c <= *pulCount) )
			{
				pSlotList[c-1] =  h;
			}
			continue;
		}
	} //end for

#ifdef PKCS11_FF
	//return the fake slotID for the attached/removed reader
	if (cal_getgnFFReaders()!= 0)
	{
		//return a higher number of slots, so FF starts waiting for slotchanges again
		if(pSlotList == NULL)
		{
			c = cal_getgnFFReaders();
		}
		else
		{
			for(; h < cal_getgnFFReaders(); h++)
			{
				log_trace(WHERE, "I: h=%i",h);
				c++;
				if (c <= *pulCount )
					pSlotList[c-1] = h;
			}
		}
	}

#endif

	//if more slots are found than can be returned in slotlist, return buffer too smal 
	if ((c > *pulCount) && (pSlotList != NULL_PTR) )
		ret = CKR_BUFFER_TOO_SMALL;

	//number of slots should always be returned.
	*pulCount = c;

cleanup:   
	log_trace(WHERE, "I: p11_unlock()");
	p11_unlock();
	log_trace(WHERE, "I: leave, ret = %i",ret);
	return ret;
}
コード例 #17
0
ファイル: SessionStore.c プロジェクト: rsms/smisk
int smisk_SessionStore_init(smisk_SessionStore *self, PyObject *args, PyObject *kwargs) {  
  log_trace("ENTER");
  return 0;
}
コード例 #18
0
ファイル: general.c プロジェクト: dagwieers/eid-mw
CK_RV C_GetSlotInfo(CK_SLOT_ID slotID, CK_SLOT_INFO_PTR pInfo)
{         
	CK_RV ret;
	P11_SLOT *slot;
	static int l=0;
	int isPresent = 0;

	log_trace(WHERE, "I: enter");

	if (p11_get_init() != BEIDP11_INITIALIZED)
	{
		log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}		

	ret = p11_lock();
	if (ret != CKR_OK)
	{
		log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
		return ret;
	}

	if (++l < LOG_MAX_REC)  
		log_trace(WHERE, "S: C_GetSlotInfo(slot %d)", slotID);

	if (pInfo == NULL_PTR) 
	{
		log_trace(WHERE, "E: pInfo = NULL");
		CLEANUP(CKR_ARGUMENTS_BAD);
	}

	slot = p11_get_slot(slotID);
	if (slot == NULL)
	{
		log_trace(WHERE, "E: p11_get_slot(%d) returns null", slotID);
		CLEANUP(CKR_SLOT_ID_INVALID);
	}

	//fill in slot info
	strcpy_n(pInfo->slotDescription, slot->name, 64, ' ');
	strcpy_n(pInfo->manufacturerID, "_ID_", 32, ' ');
	pInfo->flags = CKF_REMOVABLE_DEVICE | CKF_HW_SLOT;
	pInfo->hardwareVersion.major = 1;
	pInfo->hardwareVersion.minor = 0;
	pInfo->firmwareVersion.major = 1;
	pInfo->firmwareVersion.minor = 0;

	//check if token is present
	ret = (cal_token_present(slotID, &isPresent));
	if(ret != CKR_OK)
		goto cleanup;
	if (isPresent)
	{
		pInfo->flags |= CKF_TOKEN_PRESENT;
	}

cleanup:
	p11_unlock();
	log_trace(WHERE, "I: leave, ret = %i",ret);
	return ret;
}
コード例 #19
0
ファイル: SessionStore.c プロジェクト: rsms/smisk
PyObject *smisk_SessionStore_write(smisk_SessionStore *self, PyObject *args) {
  log_trace("ENTER");
  PyErr_SetString(PyExc_NotImplementedError, "write");
  return NULL;
}
コード例 #20
0
ファイル: general.c プロジェクト: dagwieers/eid-mw
CK_RV C_Initialize(CK_VOID_PTR pReserved)
{
	int ret = CKR_OK;
	CK_C_INITIALIZE_ARGS_PTR p_args;
	unsigned char initial_state = p11_get_init();

#if _DEBUG
	log_init(DEFAULT_LOG_FILE, LOG_LEVEL_PKCS11_INFO);
#else
	log_init(DEFAULT_LOG_FILE, LOG_LEVEL_PKCS11_NONE);
#endif
	log_trace(WHERE, "I: enter pReserved = %p",pReserved);
	if (p11_get_init() != BEIDP11_NOT_INITIALIZED)
	{
		ret = CKR_CRYPTOKI_ALREADY_INITIALIZED;
		log_trace(WHERE, "I: Module is allready initialized");
	}
	else
	{
		//g_init = BEIDP11_INITIALIZED;
		p11_set_init(BEIDP11_INITIALIZING);
		if (pReserved != NULL)
		{
			p_args = (CK_C_INITIALIZE_ARGS *)pReserved;

			if(p_args->pReserved != NULL)
			{
				ret = CKR_ARGUMENTS_BAD;
				goto cleanup;
			}
			if(	(p_args->CreateMutex == NULL) || (p_args->DestroyMutex == NULL) || \
				(p_args->LockMutex == NULL) || (p_args->UnlockMutex == NULL)	)
			{
				log_trace(WHERE, "S: use supplied locking mechanism");
				//If some, but not all, of the supplied function pointers to C_Initialize are non-NULL_PTR, 
				//then C_Initialize should return with the value CKR_ARGUMENTS_BAD.
				if(!((p_args->CreateMutex == NULL) && (p_args->DestroyMutex == NULL) && \
					(p_args->LockMutex == NULL) && (p_args->UnlockMutex == NULL)))
				{
					ret = CKR_ARGUMENTS_BAD;
					goto cleanup;
				}
			}
			log_trace(WHERE, "S: p11_init_lock");
			p11_init_lock(p_args);
		}
		cal_init();
		p11_set_init(BEIDP11_INITIALIZED);
		log_trace(WHERE, "S: Initialize this PKCS11 Module");
		log_trace(WHERE, "S: =============================");
/*#ifdef PKCS11_FF
	cal_init_pcsc();
#endif*/
	}

cleanup:
	log_trace(WHERE, "I: leave, ret = %i",ret);
	if (ret != CKR_OK) {
		p11_set_init(initial_state);
	}
	return ret;
}
コード例 #21
0
ファイル: session.c プロジェクト: 12019/svn.gov.pt
CK_RV C_GetSessionInfo(CK_SESSION_HANDLE hSession,  /* the session's handle */
                       CK_SESSION_INFO_PTR pInfo)   /* receives session information */
{
   int ret;
   char buf[256];
   P11_SESSION *pSession = NULL;
   P11_SLOT *pSlot = NULL;
   CK_TOKEN_INFO tokeninfo;
   log_trace(WHERE, "I: enter");
   ret = p11_lock();
   if (ret != CKR_OK)
   {
	   log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
	   return ret;
   }

   log_trace(WHERE, "S: C_GetSessionInfo(session %d)", hSession);

   if (pInfo == NULL_PTR) 
   {
	   ret = CKR_ARGUMENTS_BAD;
	   goto cleanup;
   }

   ret = p11_get_session(hSession, &pSession);
   if (ret)
   {
	   log_trace(WHERE, "E: Invalid session handle (%d) (%s)", hSession, log_map_error(ret));
	   goto cleanup;
   }



   pInfo->slotID = pSession->hslot;
   pInfo->flags = pSession->flags;
   pInfo->ulDeviceError = 0;

   pSlot = p11_get_slot(pSession->hslot);
   if (pSlot == NULL)
      {
      log_trace(WHERE, "E: slot not found for session %d", hSession);
      ret = CKR_SESSION_HANDLE_INVALID;
      goto cleanup;
      }

   //SO only can create RW_SO sessions
   if (pSlot->login_type == CKU_SO) 
      {
      pInfo->state = CKS_RW_SO_FUNCTIONS;
      }
   //USER can create RW or RO sessions
   else if (pSlot->login_type == CKU_USER) 
      {
      pInfo->state = (pSession->flags & CKF_RW_SESSION)? CKS_RW_USER_FUNCTIONS : CKS_RO_USER_FUNCTIONS;
      } 
   //if login not required => we can also get USER sessions without being logged on
   else 
      {
      ret = cal_get_token_info(pSession->hslot, &tokeninfo);
      if ( (ret == CKR_OK) && !(tokeninfo.flags & CKF_LOGIN_REQUIRED) )
         pInfo->state = (pSession->flags & CKF_RW_SESSION)? CKS_RW_USER_FUNCTIONS : CKS_RO_USER_FUNCTIONS;
      else
         pInfo->state = (pSession->flags & CKF_RW_SESSION) ? CKS_RW_PUBLIC_SESSION : CKS_RO_PUBLIC_SESSION;
      }

cleanup:
   p11_unlock();
   log_trace(WHERE, "I: leave, ret = %i",ret);
   return ret;
}
コード例 #22
0
ファイル: general.c プロジェクト: dagwieers/eid-mw
CK_RV C_WaitForSlotEvent(CK_FLAGS flags,   /* blocking/nonblocking flag */
	CK_SLOT_ID_PTR pSlot,  /* location that receives the slot ID */
	CK_VOID_PTR pReserved) /* reserved.  Should be NULL_PTR */

{
	CK_RV ret = CKR_OK;
	int h;
	P11_SLOT *p11Slot = NULL;
	int i = 0;
	CK_BBOOL locked = CK_FALSE;
#ifdef PKCS11_FF
	CK_BBOOL bRunning = CK_TRUE;
	long error = 0;
#endif

	log_trace(WHERE, "I: enter");

	//need to check initialization before lock, as lock might be in progress of being set up
	if (p11_get_init() != BEIDP11_INITIALIZED)
	{
		log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}	

#ifdef PKCS11_FF
	/*error = cal_check_pcsc(&bRunning);
	if(bRunning == CK_FALSE)
	{
		while( (error == 0) && (bRunning == CK_FALSE) )
		{
			cal_wait (500);
			error = cal_check_pcsc(&bRunning);

			//check if pkcs11 isn't finalizing
			if (p11_get_init() != BEIDP11_INITIALIZED)
			{
				log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NO_LONGER_INITIALIZED");
				return (CKR_CRYPTOKI_NOT_INITIALIZED);
			}	
		}
		//pcsc just got launched, so establish a new context
		ret = p11_lock();
		if (ret != CKR_OK)
		{
			log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
			return ret;
		}
		//check if nowhere else the context has been reestablished
		//TODO : if()
		cal_re_establish_context();
		p11_unlock();
	}*/
#endif

	ret = p11_lock();
	if (ret != CKR_OK)
	{
		log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
		return ret;
	}

	//check again, in case c_finalize got the lock right before we did
	//(then c_finalize will give us a chance to fall through, right before he resets the lock))
	if (p11_get_init() != BEIDP11_INITIALIZED)
	{
		log_trace(WHERE, "I: leave, CKR_CRYPTOKI_NOT_INITIALIZED");
		p11_unlock();
		return (CKR_CRYPTOKI_NOT_INITIALIZED);
	}	

	locked = CK_TRUE;

	log_trace(WHERE, "S: C_WaitForSlotEvent(flags = 0x%0x)", flags);

	// Doesn't seem to work on Linux: if you insert a card then Mozilla freezes
	// until you remove the card. This function however seems to work fine.
#ifndef _WIN32
	CLEANUP(CKR_FUNCTION_NOT_SUPPORTED);
#endif

	//first check if no events are set for slots in previous run
	//this could happen if more cards are inserted/removed at the same time
	for (i=0; i < p11_get_nreaders(); i++)
	{
		p11Slot = p11_get_slot(i);
		if(p11Slot == NULL)
			CLEANUP(CKR_FUNCTION_FAILED);
		if (p11Slot->ievent != P11_EVENT_NONE)
		{
#ifdef PKCS11_FF
			//in case the upnp reader caused the event, return a new slotnumber
			if( (i+1) == p11_get_nreaders())
			{
				if(cal_getgnFFReaders() == 0)
				{
					cal_setgnFFReaders(p11_get_nreaders()+1);
				}
				else
				{
					cal_incgnFFReaders();
				}
				i = (cal_getgnFFReaders()-1);
			}
#endif
			*pSlot = i;
			//clear event
			p11Slot->ievent = P11_EVENT_NONE;
			CLEANUP(CKR_OK);
		}
	}

	if (flags & CKF_DONT_BLOCK)
	{
		ret = cal_wait_for_slot_event(0);//0 means don't block
	}
	else
	{
		ret = cal_wait_for_slot_event(1);//1 means block, lock will get released here

		//ret is 0x30 when SCardGetStatusChange gets cancelled 
		if ((p11_get_init() == BEIDP11_NOT_INITIALIZED ) || 
			(p11_get_init() == BEIDP11_DEINITIALIZING) || 
			(ret == CKR_CRYPTOKI_NOT_INITIALIZED) )
		{
			log_trace(WHERE, "I: CKR_CRYPTOKI_NOT_INITIALIZED");
			p11_unlock();
			return(CKR_CRYPTOKI_NOT_INITIALIZED);
		}
	}
	if(ret != CKR_OK)
		goto cleanup;

	ret = cal_get_slot_changes(&h);

	if (ret == CKR_OK)
		*pSlot = h;

	//else CKR_NO_EVENT

	/* Firefox 1.5 tries to call this function (with the blocking flag)
	* in a separate thread; and this causes the pkcs11 lib to hang on Linux
	* So we might have to return "not supported" in which case Ff 1.5 defaults
	* to polling in the main thread, like before. */

cleanup:
	if(locked == CK_TRUE)
		p11_unlock();

	log_trace(WHERE, "I: leave, ret = %i",ret);
	return ret;
}
コード例 #23
0
ファイル: session.c プロジェクト: 12019/svn.gov.pt
CK_RV C_OpenSession(CK_SLOT_ID            slotID,        /* the slot's ID */
                    CK_FLAGS              flags,         /* defined in CK_SESSION_INFO */
                    CK_VOID_PTR           pApplication,  /* pointer passed to callback */
                    CK_NOTIFY             Notify,        /* notification callback function */
                    CK_SESSION_HANDLE_PTR phSession)     /* receives new session handle */
{
   int ret;
   P11_SLOT* pSlot = NULL;
   P11_SESSION *pSession = NULL;

//   CAutoMutex(&g_oSlotMutex);
log_trace(WHERE, "I: enter");
   ret = p11_lock(slotID);   /* mutex per slot slot 0 tot 9 FF=global slot*/
   if (ret != CKR_OK)
{
	log_trace(WHERE, "I: leave, p11_lock failed with %i",ret);
   return ret;
}

   log_trace(WHERE, "S: C_OpenSession (slot %d)", slotID);

   if (!(flags & CKF_SERIAL_SESSION)) 
     {
     ret = CKR_SESSION_PARALLEL_NOT_SUPPORTED;
     goto cleanup;
     }

   //XXX check this
/*   if (flags & ~(CKF_SERIAL_SESSION | CKF_RW_SESSION))
      {
      ret = CKR_ARGUMENTS_BAD;
      goto cleanup;
      }*/

   pSlot = p11_get_slot(slotID);
   if (pSlot == NULL)
      {
      log_trace(WHERE, "E: p11_get_slot(%d) returns null", slotID);
      ret = CKR_SLOT_ID_INVALID;
      goto cleanup;
      }

  /* Check that no conflictions sessions exist */
  /* RO session when SO session exists is not allowed */
  if ( !(flags & CKF_RW_SESSION) && (pSlot->login_type == CKU_SO)) 
     {
     log_trace(WHERE, "E: R/W Session exists", slotID);
     ret = CKR_SESSION_READ_WRITE_SO_EXISTS;
     goto cleanup;
     }

  //get a free session object reserve it by setting inuse flag
  ret = p11_get_free_session(phSession, &pSession);
  if (ret != CKR_OK)
     {
     log_trace(WHERE, "E: p11_get_free_session() returns %d", ret);
     goto cleanup;
     }

  //connect to card if present
  ret = cal_connect(slotID);
  if (ret != CKR_OK)
     {
	//printf("Did not connect to card!!!!\n");
     log_trace(WHERE, "E: cal_connect(slot %d) failed", slotID);
     //release session so it can be reused
     pSession->inuse = 0;
     goto cleanup;
     }
//printf("in use? %d... slotID = %d\n",pSession->inuse,slotID);
  pSession->hslot = slotID;
  pSession->flags = flags;
  pSession->pdNotify = pApplication;
  pSession->pfNotify = Notify;
  //initial state 
  pSession->state = P11_CARD_STILL_PRESENT;

  /* keep the nr of sessions for this slot */
  pSlot->nsessions++;

  log_trace(WHERE, "S: Open session (slot %d: hsession = %d )", slotID, *phSession);

cleanup:
   p11_unlock();
   log_trace(WHERE, "I: leave, ret = %i",ret);
   return ret;
}
コード例 #24
0
ファイル: openssl.cpp プロジェクト: mwuehrer/tntnet
 void OpensslStream::accept(const OpensslServer& server, bool inherit)
 {
   log_trace("accept");
   cxxtools::net::TcpSocket::accept(server, inherit);
 }
コード例 #25
0
int
read_bluetooth(time_t const bt_timeout, int const sfd, int *rr, unsigned char *received, int cc, unsigned char *last_sent, int *terminated )
{
    int bytes_read,i;
    unsigned char buf[1024]; /*read buffer*/
    unsigned char header[3]; /*read buffer*/
    struct timeval tv;
    fd_set readfds;

    tv.tv_sec = bt_timeout; // set timeout of reading
    tv.tv_usec = 0;
    memset(buf,0,1024);

    FD_ZERO(&readfds);
    FD_SET((sfd), &readfds);

    select((sfd)+1, &readfds, NULL, NULL, &tv);

    (*terminated) = 0; // Tag to tell if string has 7e termination
    // first read the header to get the record length
    if (FD_ISSET((sfd), &readfds)){     // did we receive anything within 5 seconds
        bytes_read = recv((sfd), header, sizeof(header), 0); //Get length of string
        (*rr) = 0;
        for( i=0; i<sizeof(header); i++ ) {
            received[(*rr)] = header[i];
//            log_trace("%02x ", received[i]);
            (*rr)++;
        }
    }
    else
    {
       log_warning("Timeout reading bluetooth socket");
       (*rr) = 0;
       memset(received,0,1024);
       return -1;
    }
    if (FD_ISSET((sfd), &readfds)){     // did we receive anything within 5 seconds
        bytes_read = recv((sfd), buf, header[1]-3, 0); //Read the length specified by header
    }
    else
    {
       log_warning("Timeout reading bluetooth socket");
       (*rr) = 0;
       memset(received,0,1024);
       return -1;
    }
    if ( bytes_read > 0){
        hlog_debug("Receiving - header", header, sizeof(header), 12);
        hlog_debug("Receiving - body  ", buf, bytes_read, 0);

        if ((cc==bytes_read)&&(memcmp(received,last_sent,cc) == 0)){
           log_error( "ERROR received what we sent!" );
           abort();
           //Need to do something
        }
        if( buf[ bytes_read-1 ] == 0x7e )
           (*terminated) = 1;
        else
           (*terminated) = 0;
        for (i=0;i<bytes_read;i++){ //start copy the rec buffer in to received
            if (buf[i] == 0x7d){ //did we receive the escape char
                switch (buf[i+1]){   // act depending on the char after the escape char

                    case 0x5e :
                        received[(*rr)] = 0x7e;
                        break;

                    case 0x5d :
                        received[(*rr)] = 0x7d;
                        break;

                    default :
                        received[(*rr)] = buf[i+1] ^ 0x20;
                        break;
                }
                    i++;
            }
            else {
               received[(*rr)] = buf[i];
            }
//            log_trace("%02x ", received[(*rr)]);
            (*rr)++;
        }
        fix_length_received( received, rr );
        log_trace("received", received, *rr, 0);
    }
    return 0;
}
コード例 #26
0
int
queue_message_commit(uint32_t msgid)
{
	int	r;
	char	msgpath[PATH_MAX];
	char	tmppath[PATH_MAX];
	FILE	*ifp = NULL;
	FILE	*ofp = NULL;

	profile_enter("queue_message_commit");

	queue_message_path(msgid, msgpath, sizeof(msgpath));

	if (env->sc_queue_flags & QUEUE_COMPRESSION) {
		bsnprintf(tmppath, sizeof tmppath, "%s.comp", msgpath);
		ifp = fopen(msgpath, "r");
		ofp = fopen(tmppath, "w+");
		if (ifp == NULL || ofp == NULL)
			goto err;
		if (! compress_file(ifp, ofp))
			goto err;
		fclose(ifp);
		fclose(ofp);
		ifp = NULL;
		ofp = NULL;

		if (rename(tmppath, msgpath) == -1) {
			if (errno == ENOSPC)
				return (0);
			unlink(tmppath);
			log_warn("rename");
			return (0);
		}
	}

#ifdef HAVE_GCM_CRYPTO
	if (env->sc_queue_flags & QUEUE_ENCRYPTION) {
		bsnprintf(tmppath, sizeof tmppath, "%s.enc", msgpath);
		ifp = fopen(msgpath, "r");
		ofp = fopen(tmppath, "w+");
		if (ifp == NULL || ofp == NULL)
			goto err;
		if (! crypto_encrypt_file(ifp, ofp))
			goto err;
		fclose(ifp);
		fclose(ofp);
		ifp = NULL;
		ofp = NULL;

		if (rename(tmppath, msgpath) == -1) {
			if (errno == ENOSPC)
				return (0);
			unlink(tmppath);
			log_warn("rename");
			return (0);
		}
	}
#endif

	r = handler_message_commit(msgid, msgpath);
	profile_leave();

	/* in case it's not done by the backend */
	unlink(msgpath);

	log_trace(TRACE_QUEUE,
	    "queue-backend: queue_message_commit(%08"PRIx32") -> %d",
	    msgid, r);

	return (r);

err:
	if (ifp)
		fclose(ifp);
	if (ofp)
		fclose(ofp);
	return 0;
}
コード例 #27
0
ファイル: slave.cpp プロジェクト: ddling1216/ssdb
int Slave::proc_sync(const Binlog &log, const std::vector<Bytes> &req){
	switch(log.cmd()){
		case BinlogCommand::KSET:
			{
				if(req.size() != 2){
					break;
				}
				std::string key;
				if(decode_kv_key(log.key(), &key) == -1){
					break;
				}
				log_trace("set %s", hexmem(key.data(), key.size()).c_str());
				if(ssdb->set(key, req[1], log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::KDEL:
			{
				std::string key;
				if(decode_kv_key(log.key(), &key) == -1){
					break;
				}
				log_trace("del %s", hexmem(key.data(), key.size()).c_str());
				if(ssdb->del(key, log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::HSET:
			{
				if(req.size() != 2){
					break;
				}
				std::string name, key;
				if(decode_hash_key(log.key(), &name, &key) == -1){
					break;
				}
				log_trace("hset %s %s",
					hexmem(name.data(), name.size()).c_str(),
					hexmem(key.data(), key.size()).c_str());
				if(ssdb->hset(name, key, req[1], log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::HDEL:
			{
				std::string name, key;
				if(decode_hash_key(log.key(), &name, &key) == -1){
					break;
				}
				log_trace("hdel %s %s",
					hexmem(name.data(), name.size()).c_str(),
					hexmem(key.data(), key.size()).c_str());
				if(ssdb->hdel(name, key, log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::ZSET:
			{
				if(req.size() != 2){
					break;
				}
				std::string name, key;
				if(decode_zset_key(log.key(), &name, &key) == -1){
					break;
				}
				log_trace("zset %s %s",
					hexmem(name.data(), name.size()).c_str(),
					hexmem(key.data(), key.size()).c_str());
				if(ssdb->zset(name, key, req[1], log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::ZDEL:
			{
				std::string name, key;
				if(decode_zset_key(log.key(), &name, &key) == -1){
					break;
				}
				log_trace("zdel %s %s",
					hexmem(name.data(), name.size()).c_str(),
					hexmem(key.data(), key.size()).c_str());
				if(ssdb->zdel(name, key, log_type) == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::QSET:
		case BinlogCommand::QPUSH_BACK:
		case BinlogCommand::QPUSH_FRONT:
			{
				if(req.size() != 2){
					break;
				}
				std::string name;
				uint64_t seq;
				if(decode_qitem_key(log.key(), &name, &seq) == -1){
					break;
				}
				if(seq < QITEM_MIN_SEQ || seq > QITEM_MAX_SEQ){
					break;
				}
				int ret;
				if(log.cmd() == BinlogCommand::QSET){
					log_trace("qset %s %" PRIu64 "", hexmem(name.data(), name.size()).c_str(), seq);
					ret = ssdb->qset_by_seq(name, seq, req[1], log_type);
				}else if(log.cmd() == BinlogCommand::QPUSH_BACK){
					log_trace("qpush_back %s", hexmem(name.data(), name.size()).c_str());
					ret = ssdb->qpush_back(name, req[1], log_type);
				}else{
					log_trace("qpush_front %s", hexmem(name.data(), name.size()).c_str());
					ret = ssdb->qpush_front(name, req[1], log_type);
				}
				if(ret == -1){
					return -1;
				}
			}
			break;
		case BinlogCommand::QPOP_BACK:
		case BinlogCommand::QPOP_FRONT:
			{
				int ret;
				const Bytes name = log.key();
				std::string tmp;
				if(log.cmd() == BinlogCommand::QPOP_BACK){
					log_trace("qpop_back %s", hexmem(name.data(), name.size()).c_str());
					ret = ssdb->qpop_back(name, &tmp, log_type);
				}else{
					log_trace("qpop_front %s", hexmem(name.data(), name.size()).c_str());
					ret = ssdb->qpop_front(name, &tmp, log_type);
				}
				if(ret == -1){
					return -1;
				}
			}
			break;
		default:
			log_error("unknown binlog, type=%d, cmd=%d", log.type(), log.cmd());
			break;
	}
	this->last_seq = log.seq();
	if(log.type() == BinlogType::COPY){
		this->last_key = log.key().String();
	}
	this->save_status();
	return 0;
}
コード例 #28
0
int
queue_message_fd_r(uint32_t msgid)
{
	int	fdin, fdout = -1, fd = -1;
	FILE	*ifp = NULL;
	FILE	*ofp = NULL;

	profile_enter("queue_message_fd_r");
	fdin = handler_message_fd_r(msgid);
	profile_leave();

	log_trace(TRACE_QUEUE,
	    "queue-backend: queue_message_fd_r(%08"PRIx32") -> %d", msgid, fdin);

	if (fdin == -1)
		return (-1);

#ifdef HAVE_GCM_CRYPTO
	if (env->sc_queue_flags & QUEUE_ENCRYPTION) {
		if ((fdout = mktmpfile()) == -1)
			goto err;
		if ((fd = dup(fdout)) == -1)
			goto err;
		if ((ifp = fdopen(fdin, "r")) == NULL)
			goto err;
		fdin = fd;
		fd = -1;
		if ((ofp = fdopen(fdout, "w+")) == NULL)
			goto err;

		if (! crypto_decrypt_file(ifp, ofp))
			goto err;

		fclose(ifp);
		ifp = NULL;
		fclose(ofp);
		ofp = NULL;
		lseek(fdin, SEEK_SET, 0);
	}
#endif

	if (env->sc_queue_flags & QUEUE_COMPRESSION) {
		if ((fdout = mktmpfile()) == -1)
			goto err;
		if ((fd = dup(fdout)) == -1)
			goto err;
		if ((ifp = fdopen(fdin, "r")) == NULL)
			goto err;
		fdin = fd;
		fd = -1;
		if ((ofp = fdopen(fdout, "w+")) == NULL)
			goto err;

		if (! uncompress_file(ifp, ofp))
			goto err;

		fclose(ifp);
		ifp = NULL;
		fclose(ofp);
		ofp = NULL;
		lseek(fdin, SEEK_SET, 0);
	}

	return (fdin);

err:
	if (fd != -1)
		close(fd);
	if (fdin != -1)
		close(fdin);
	if (fdout != -1)
		close(fdout);
	if (ifp)
		fclose(ifp);
	if (ofp)
		fclose(ofp);
	return -1;
}
コード例 #29
0
ファイル: backend_sync.cpp プロジェクト: CowLeo/ssdb
// sync seq and/or binlog
int BackendSync::Client::sync(BinlogQueue *logs){
	Binlog log;
	while(1){
		int ret = 0;
		uint64_t expect_seq = this->last_seq + 1;
		if(this->status == Client::COPY && this->last_seq == 0){
			ret = logs->find_last(&log);
		}else{
			ret = logs->find_next(expect_seq, &log);
		}
		if(ret == 0){
			return 0;
		}
		if(this->status == Client::COPY && log.key() > this->last_key){
			log_debug("fd: %d, last_key: '%s', drop: %s",
				link->fd(),
				hexmem(this->last_key.data(), this->last_key.size()).c_str(),
				log.dumps().c_str());
			this->last_seq = log.seq();
			// WARN: When there are writes behind last_key, we MUST create
			// a new iterator, because iterator will not know this key.
			// Because iterator ONLY iterates throught keys written before
			// iterator is created.
			if(this->iter){
				delete this->iter;
				this->iter = NULL;
			}
			continue;
		}
		if(this->last_seq != 0 && log.seq() != expect_seq){
			log_warn("%s:%d fd: %d, OUT_OF_SYNC! log.seq: %" PRIu64 ", expect_seq: %" PRIu64 "",
				link->remote_ip, link->remote_port,
				link->fd(),
				log.seq(),
				expect_seq
				);
			this->out_of_sync();
			return 1;
		}
	
		// update last_seq
		this->last_seq = log.seq();

		char type = log.type();
		if(type == BinlogType::MIRROR && this->is_mirror){
			if(this->last_seq - this->last_noop_seq >= 1000){
				this->noop();
				return 1;
			}else{
				continue;
			}
		}
		
		break;
	}

	int ret = 0;
	std::string val;
	switch(log.cmd()){
		case BinlogCommand::KSET:
		case BinlogCommand::HSET:
		case BinlogCommand::ZSET:
		case BinlogCommand::QSET:
		case BinlogCommand::QPUSH_BACK:
		case BinlogCommand::QPUSH_FRONT:
			ret = backend->ssdb->raw_get(log.key(), &val);
			if(ret == -1){
				log_error("fd: %d, raw_get error!", link->fd());
			}else if(ret == 0){
				//log_debug("%s", hexmem(log.key().data(), log.key().size()).c_str());
				log_trace("fd: %d, skip not found: %s", link->fd(), log.dumps().c_str());
			}else{
				log_trace("fd: %d, %s", link->fd(), log.dumps().c_str());
				link->send(log.repr(), val);
			}
			break;
		case BinlogCommand::KDEL:
		case BinlogCommand::HDEL:
		case BinlogCommand::ZDEL:
		case BinlogCommand::QPOP_BACK:
		case BinlogCommand::QPOP_FRONT:
			log_trace("fd: %d, %s", link->fd(), log.dumps().c_str());
			link->send(log.repr());
			break;
	}
	return 1;
}
コード例 #30
0
ファイル: log-malloc2.c プロジェクト: m0t/log-malloc2
void *realloc(void *ptr, size_t size)
{
	struct log_malloc_s *mem;
	sig_atomic_t memuse = 0;
	sig_atomic_t memruse = 0;
	sig_atomic_t memchange = 0;
#ifdef HAVE_MALLOC_USABLE_SIZE
	size_t       rsize = 0;
	sig_atomic_t memrchange = 0;
#endif

	if(!DL_RESOLVE_CHECK(realloc))
		return NULL;

	mem = (ptr != NULL) ? MEM_HEAD(ptr) : NULL;

	//FIXME: not handling foreign memory here (seems not needed)
	if(mem && (mem->size != ~mem->cb))
	{
		assert(mem->size != ~mem->cb);
		return NULL;
	}

	if((mem = real_realloc(mem, size + MEM_OFF)) != NULL)
	{
		memchange = (ptr) ? size - mem->size : size;
		memuse = __sync_add_and_fetch(&g_ctx.mem_used, memchange);

#ifdef HAVE_MALLOC_USABLE_SIZE
		rsize = malloc_usable_size(mem);

		memrchange = (ptr) ? rsize - mem->rsize : rsize;
		memruse = __sync_add_and_fetch(&g_ctx.mem_rused, memrchange);
#endif
	}
#ifndef DISABLE_CALL_COUNTS
	(void)__sync_fetch_and_add(&g_ctx.stat.realloc, 1);
	g_ctx.stat.unrel_sum++;
#endif

	if(!g_ctx.memlog_disabled)
	{
		int s;
		char buf[LOG_BUFSIZE];

		s = snprintf(buf, sizeof(buf), "+ realloc %d %p %p (%zu %zu) [%u:%u]\n",
			memchange, ptr,
			MEM_PTR(mem), (mem ? mem->size : 0), size,
			memuse, memruse);

		log_trace(buf, s, sizeof(buf), 1);
	}

	/* now we can update */
	if(mem != NULL)
	{
		mem->size = size;
		mem->cb = ~mem->size;
#ifdef HAVE_MALLOC_USABLE_SIZE
		mem->rsize = rsize;
#endif
	}
	return MEM_PTR(mem);
}