コード例 #1
0
ファイル: rendezvous.c プロジェクト: SRI-CSL/jumpbox
static const char *
rdv_peel_base(void) {
	const char	*response = NULL;
	const char	*nep;
	json_error_t	error;
	json_t		*root;

	/* Just in case */
	fassert(ONION_TYPE(l_current_onion) == BASE);

	nep = (char *)ONION_DATA(l_current_onion);

	log_dbg("nep = %s", nep);

	root = json_loads(nep, 0, &error);
	if (root != NULL) {
		/* Pass the NET to ACS so that it can Dance */
		acs_set_net(root);
		/* XXX: might fail if already dancing, check return */

		response = rdv_make_peel_response(
			"NET passed to ACS", "Complete");

		/* Done with it here */
		json_decref(root);
	} else {
		log_dbg("data = %s error: line: %d msg: %s",
			 nep, error.line, error.text);
		response = rdv_make_peel_response(
			"Sorry your nep did not parse as JSON", "");
	}

	return (response);
}
コード例 #2
0
ファイル: main-redir.c プロジェクト: DavidWeblib/Coova-Chilli
static int
check_regex(regex_t *re, char *regex, char *s) {
  int ret;

#if(_debug_)
  log_dbg("Checking %s =~ %s", s, regex);
#endif

#if defined (__FreeBSD__) || defined (__APPLE__) || defined (__OpenBSD__) || defined (__NetBSD__)
  if (!re->re_g)
#else
  if (!re->allocated) 
#endif
  {
    if ((ret = regcomp(re, regex, REG_EXTENDED | REG_NOSUB)) != 0) {
      char error[512];
      regerror(ret, re, error, sizeof(error));
      log_err(0, "regcomp(%s) failed (%s)", regex, error);
      regex[0] = 0;
      return -1;
    }
  }
  
  if ((ret = regexec(re, s, 0, 0, 0)) == 0) {
    
    log_dbg("Matched regex %s", regex);
    return 0;
    
  }

  return 1;
}
コード例 #3
0
ファイル: keymanage.c プロジェクト: kleopatra999/cryptsetup
static int LUKS_check_device_size(struct crypt_device *ctx, size_t keyLength)
{
	struct device *device = crypt_metadata_device(ctx);
	uint64_t dev_sectors, hdr_sectors;

	if (!keyLength)
		return -EINVAL;

	if(device_size(device, &dev_sectors)) {
		log_dbg("Cannot get device size for device %s.", device_path(device));
		return -EIO;
	}

	dev_sectors >>= SECTOR_SHIFT;
	hdr_sectors = LUKS_device_sectors(keyLength);
	log_dbg("Key length %zu, device size %" PRIu64 " sectors, header size %"
		PRIu64 " sectors.",keyLength, dev_sectors, hdr_sectors);

	if (hdr_sectors > dev_sectors) {
		log_err(ctx, _("Device %s is too small. (LUKS requires at least %" PRIu64 " bytes.)\n"),
			device_path(device), hdr_sectors * SECTOR_SIZE);
		return -EINVAL;
	}

	return 0;
}
コード例 #4
0
ファイル: mssl.c プロジェクト: wichert/coova-chilli
int SSL_accept2(SSL *ssl) {
  
  char buf[1024];
  int  rc;
  
#if(_debug_)
  log_dbg("MatrixSSL_accept2()");
#endif

  rc = _ssl_read(ssl, buf, sizeof(buf));

  if (rc == 0) {
    if (ssl->status == SSL_SOCKET_EOF || ssl->status == SSL_SOCKET_CLOSE_NOTIFY) {
      log_dbg("EOF or Closed");
      return -1;
    }
    return 0;
  } else if (rc > 0) {
    log_dbg("Accept2() returning %d", rc);
    return rc;
  } else {

    if (ssl->status == EAGAIN || ssl->status == EWOULDBLOCK)
      return 0;

    log_warn(ssl->status, "Error rc %d", rc);
    return -1;
  }
  
  return 1;
}
コード例 #5
0
ファイル: socket_libevent.c プロジェクト: wuhong1986/cutils
static void cb_conn_read_cli(struct bufferevent *bev, void *user_data)
{
    void*    buffer  = NULL;
    uint32_t buf_len = 0;
    struct evbuffer *buf_in = bufferevent_get_input(bev);
    cli_cmd_t cmd;
    cstr *json = cstr_new();

    cli_cmd_init(&cmd);

    /* bufferevent_lock(bev); */

    /* read data frome buffer in */
    buf_len = evbuffer_get_length(buf_in);
    buffer = calloc(1, buf_len);
    bufferevent_read(bev, buffer, buf_len);

    /* bufferevent_unlock(bev); */

    log_dbg("recv command: %s", (char*)buffer);
    cli_parse(&cmd, (char*)buffer);
    cli_cmd_to_json(&cmd, json);
    log_dbg("cli response: %s", cstr_body(json));

    bufferevent_send(bev, cstr_body(json), cstr_len(json) + 1);

    /* put data to addr recv buffer, and translate to command format */
    cli_cmd_release(&cmd);
    cstr_free(json);
    free(buffer);
    /* bufferevent_free(bev); */
}
コード例 #6
0
static VALUE ruby_function_proxy(VALUE self, VALUE _args)
{
    ID id = rb_frame_last_func();

    value_t* value = dict_lookup(global->functions, (void*)id);

    if(!value) {
        language_error(global->li, "[ruby] couldn't retrieve constant %s", rb_id2name(id));
        return Qnil;
    }

    if(value->type == TYPE_FUNCTION) {
        log_dbg("[ruby] calling function %s", rb_id2name(id));
        value_t*args = ruby_to_value(_args);
        value_t*ret = value->call(value, args);
        value_destroy(args);
        volatile VALUE r = value_to_ruby(ret);
        value_destroy(ret);
        log_dbg("[rb] returning from callback");
        return r;
    } else {
        log_dbg("[ruby] retrieving constant %s (%s)", rb_id2name(id), type_to_string(value->type));
        volatile VALUE r = value_to_ruby(value);
        return r;
    }
    return Qnil;
}
コード例 #7
0
ファイル: authcli.c プロジェクト: BackupGGCode/wl500g
static void request_auth_child(void)
{
    int sock;
    int ret;
    struct sockaddr_in serveraddr;

    sock = socket (PF_INET, SOCK_STREAM, 0);
    if ((sock > 0) && init_sockaddr(&serveraddr, HOSTNAME, SERV_TCP_PORT)) {
	log_dbg("connecting to auth server at %s", inet_ntoa(serveraddr.sin_addr));

	while(1) {
	    ret = connect(sock, (struct sockaddr*) &serveraddr, sizeof(serveraddr));
	    if (ret == ENETUNREACH) {
		log_dbg("network unreachable - reconnecting");
		sleep(RECONNECT_DELAY);
	    } else
	       break;
	}

	if (!ret) {
	    log_dbg("sending init request");
	    send(sock, "IMAL", 4, 0);
	} else
	    log_dbg("connect error: %s", strerror(errno));
	close(sock);
    }
}
コード例 #8
0
static int validate_luks2_json_object(json_object *jobj_hdr)
{
	int r;

	/* we require top level object to be of json_type_object */
	r = !json_object_is_type(jobj_hdr, json_type_object);
	if (r) {
		log_dbg("ERROR: Resulting object is not a json object type");
		return r;
	}

	r = LUKS2_hdr_validate(jobj_hdr);
	if (r) {
		log_dbg("Repairing JSON metadata.");
		/* try to correct known glitches */
		LUKS2_hdr_repair(jobj_hdr);

		/* run validation again */
		r = LUKS2_hdr_validate(jobj_hdr);
	}

	if (r)
		log_dbg("ERROR: LUKS2 validation failed");

	return r;
}
コード例 #9
0
ファイル: conn.c プロジェクト: phelandhu/rpmbuild
static int 
_conn_bstring_readhandler(struct conn_t *conn, void *ctx) {
  bstring data = (bstring)ctx;
  int ret;
  ballocmin(data, data->slen + 128);

  ret = safe_read(conn->sock, 
		  data->data + data->slen,
		  data->mlen - data->slen);

  if (ret > 0) {
#if(_debug_)
    log_dbg("bstring_read: %d bytes", ret);
#endif
    data->slen += ret;
  } else {
#if(_debug_)
    log_dbg("socket closed!");
    log_dbg("<== [%s]", data->data);
#endif
    conn_finish(conn);
  }

  return ret;
}
コード例 #10
0
static int validate_json_area(const char *json_area, int start, int length)
{
	char c;

	/* Enforce there are no needless opening bytes */
	if (*json_area != '{') {
		log_dbg("ERROR: Opening character must be left curly bracket: '{'.");
		return -EINVAL;
	}

	if (start >= length) {
		log_dbg("ERROR: Missing trailing null byte beyond parsed json data string.");
		return -EINVAL;
	}

	/*
	 * TODO:
	 *	validate there are legal json format characters between
	 *	'json_area' and 'json_area + start'
	 */

	do {
		c = *(json_area + start);
		if (c != '\0') {
			log_dbg("ERROR: Forbidden ascii code 0x%02hhx found beyond json data string at offset %d.",
				c, start);
			return -EINVAL;
		}
	} while (++start < length);

	return 0;
}
コード例 #11
0
static int LUKS2_check_device_size(struct crypt_device *cd, struct device *device,
				   uint64_t hdr_size, int falloc)
{
	uint64_t dev_size;

	if (device_size(device, &dev_size)) {
		log_dbg("Cannot get device size for device %s.", device_path(device));
		return -EIO;
	}

	log_dbg("Device size %" PRIu64 ", header size %"
		PRIu64 ".", dev_size, hdr_size);

	if (hdr_size > dev_size) {
		/* If it is header file, increase its size */
		if (falloc && !device_fallocate(device, hdr_size))
			return 0;

		log_err(cd, _("Device %s is too small. (LUKS2 requires at least %" PRIu64 " bytes.)"),
			device_path(device), hdr_size);
		return -EINVAL;
	}

	return 0;
}
コード例 #12
0
/*
 * Helper functions
 */
json_object *parse_json_len(const char *json_area, int length, int *end_offset)
{
	json_object *jobj;
	struct json_tokener *jtok;

	if (!json_area || length <= 0)
		return NULL;

	jtok = json_tokener_new();
	if (!jtok) {
		log_dbg("ERROR: Failed to init json tokener");
		return NULL;
	}

	jobj = json_tokener_parse_ex(jtok, json_area, length);
	if (!jobj)
		log_dbg("ERROR: Failed to parse json data (%d): %s",
			json_tokener_get_error(jtok),
			json_tokener_error_desc(json_tokener_get_error(jtok)));
	else
		*end_offset = jtok->char_offset;

	json_tokener_free(jtok);

	return jobj;
}
コード例 #13
0
ファイル: keymanage.c プロジェクト: kleopatra999/cryptsetup
/* Try to open a particular key slot */
static int LUKS_open_key(unsigned int keyIndex,
		  const char *password,
		  size_t passwordLen,
		  struct luks_phdr *hdr,
		  struct volume_key *vk,
		  struct crypt_device *ctx)
{
	crypt_keyslot_info ki = LUKS_keyslot_info(hdr, keyIndex);
	struct volume_key *derived_key;
	char *AfKey;
	size_t AFEKSize;
	int r;

	log_dbg("Trying to open key slot %d [%s].", keyIndex,
		dbg_slot_state(ki));

	if (ki < CRYPT_SLOT_ACTIVE)
		return -ENOENT;

	derived_key = crypt_alloc_volume_key(hdr->keyBytes, NULL);
	if (!derived_key)
		return -ENOMEM;

	assert(vk->keylength == hdr->keyBytes);
	AFEKSize = AF_split_sectors(vk->keylength, hdr->keyblock[keyIndex].stripes) * SECTOR_SIZE;
	AfKey = crypt_safe_alloc(AFEKSize);
	if (!AfKey) {
		r = -ENOMEM;
		goto out;
	}

	r = crypt_pbkdf("pbkdf2", hdr->hashSpec, password, passwordLen,
			hdr->keyblock[keyIndex].passwordSalt, LUKS_SALTSIZE,
			derived_key->key, hdr->keyBytes,
			hdr->keyblock[keyIndex].passwordIterations);
	if (r < 0)
		goto out;

	log_dbg("Reading key slot %d area.", keyIndex);
	r = LUKS_decrypt_from_storage(AfKey,
				      AFEKSize,
				      hdr->cipherName, hdr->cipherMode,
				      derived_key,
				      hdr->keyblock[keyIndex].keyMaterialOffset,
				      ctx);
	if (r < 0)
		goto out;

	r = AF_merge(AfKey,vk->key,vk->keylength,hdr->keyblock[keyIndex].stripes,hdr->hashSpec);
	if (r < 0)
		goto out;

	r = LUKS_verify_volume_key(hdr, vk);
	if (!r)
		log_verbose(ctx, _("Key slot %d unlocked.\n"), keyIndex);
out:
	crypt_safe_free(AfKey);
	crypt_free_volume_key(derived_key);
	return r;
}
コード例 #14
0
ファイル: main-redir.c プロジェクト: DavidWeblib/Coova-Chilli
/*
 * Return values:
 *    0 == nothing to write
 *   -1 == error that closed socket
 *    1 == normal write
 */
static int redir_cli_rewrite(redir_request *req, struct conn_t *conn) {
  if (conn_write_remaining(conn)) {
    int w = net_write(req->socket_fd,
		      conn->read_buf->data +
		      conn->read_pos,
		      conn->read_buf->slen -
		      conn->read_pos);
    if (w < 0 && errno != EWOULDBLOCK && errno != EAGAIN) {
      log_err(errno, "net_write(%d)",
	      conn->read_buf->slen -
	      conn->read_pos);
      redir_conn_finish(conn, req);
      return -1;
    } else if (w > 0) {
#if(_debug_)      
      log_dbg("client (re)write: %d", w);
#endif
      conn->read_pos += w;
      if (conn->read_pos == conn->read_buf->slen) {
	log_dbg("emptying write queue");
	conn->read_pos = 0;
	bassigncstr(conn->read_buf, "");
      }
    }
    return 1;
  }
  return 0;
}
コード例 #15
0
ファイル: socket_libevent.c プロジェクト: wuhong1986/cutils
static void conn_eventcb_async(struct bufferevent *bev, short events, void *user_data)
{
    addr_t* addr = (addr_t*)user_data;
    addr_sock_t *addr_sock = (addr_sock_t*)addr_get_addr_info(addr);
    bool  is_error = false;

    if (events & BEV_EVENT_EOF) {
        is_error = true;
        log_dbg("Connection(dev:%s type:%s) closed.", addr_get_dev_name(addr),
                                                      addr_get_type_name(addr));
    } else if (events & BEV_EVENT_ERROR) {
        is_error = true;
        log_dbg("Got an error on the connection: %s",
                strerror(errno));/*XXX win32*/
    } else {
        log_dbg("conn_eventcb other");
    }

    if(is_error){
        addr_sock->fd  = SOCK_FD_INVALID;
        addr_sock->bev = NULL;
        bufferevent_free(bev);
    }

    /* None of the other events can happen here, since we haven't enabled
     * timeouts */
    /* bufferevent_free(bev); */
}
コード例 #16
0
ファイル: garden.c プロジェクト: kernel-digger/coova-chilli
int pass_through_rem(pass_through * ptlist, uint32_t * ptcnt, pass_through * pt
#ifdef HAVE_PATRICIA
		     , patricia_tree_t * ptree
#endif
    )
{
	uint32_t cnt = *ptcnt;
	int i;

	for (i = 0; i < cnt; i++) {
		if (pt_equal(&ptlist[i], pt)) {
			log_dbg
			    ("Uamallowed removing #%d: proto=%d host=%s port=%d",
			     i, pt->proto, inet_ntoa(pt->host), pt->port);
			log_dbg("Shifting uamallowed list %d to %d", i, cnt);
			for (; i < cnt - 1; i++)
				memcpy(&ptlist[i], &ptlist[i + 1],
				       sizeof(pass_through));
			*ptcnt = *ptcnt - 1;
			break;
		}
	}

#ifdef HAVE_PATRICIA
	if (ptree)
		garden_patricia_rem(pt, ptree);
#endif

	return 0;
}
コード例 #17
0
static int LUKS_check_device_size(struct crypt_device *ctx, const struct luks_phdr *hdr, int falloc)
{
	struct device *device = crypt_metadata_device(ctx);
	uint64_t dev_sectors, hdr_sectors;

	if (!hdr->keyBytes)
		return -EINVAL;

	if (device_size(device, &dev_sectors)) {
		log_dbg("Cannot get device size for device %s.", device_path(device));
		return -EIO;
	}

	dev_sectors >>= SECTOR_SHIFT;
	hdr_sectors = LUKS_device_sectors(hdr);
	log_dbg("Key length %u, device size %" PRIu64 " sectors, header size %"
		PRIu64 " sectors.", hdr->keyBytes, dev_sectors, hdr_sectors);

	if (hdr_sectors > dev_sectors) {
		/* If it is header file, increase its size */
		if (falloc && !device_fallocate(device, hdr_sectors << SECTOR_SHIFT))
			return 0;

		log_err(ctx, _("Device %s is too small. (LUKS1 requires at least %" PRIu64 " bytes.)"),
			device_path(device), hdr_sectors * SECTOR_SIZE);
		return -EINVAL;
	}

	return 0;
}
コード例 #18
0
ファイル: socket_libevent.c プロジェクト: wuhong1986/cutils
int socket_cli_send_request(const char *ip, uint16_t port, const char *request_str)
{
    int fd = 0;
    int write_cnt = 0;
    struct sockaddr_in saddr;

    fd = Socket(AF_INET, SOCK_STREAM, 0);
    saddr.sin_family = AF_INET;
    saddr.sin_port = htons(port);
    inet_aton(ip, (struct in_addr*)&(saddr.sin_addr.s_addr));
    if(connect(fd, (struct sockaddr *)(&saddr), sizeof(struct sockaddr_in)) < 0) {
        log_dbg("connect to %s:%d failed: %s", ip, port, strerror(errno));
    }

    log_dbg("connect to %s:%d OK", ip, port);
    write_cnt = write(fd, request_str, strlen(request_str) + 1);

    if(write_cnt != strlen(request_str) + 1) {
        log_dbg("%s failed, we want %d but recv %d", __FUNCTION__, strlen(request_str) + 1, write_cnt);
        fd = -1;
        SOCKET_CLOSE(fd);
    }

    return fd;
}
コード例 #19
0
ファイル: utils_device.c プロジェクト: feibob/cryptsetup
/* Get data size in bytes */
int device_size(struct device *device, uint64_t *size)
{
	struct stat st;
	int devfd, r = -EINVAL;

    log_dbg("device_size: %s", device->path);
	devfd = open(device->path, O_RDONLY);
	if(devfd == -1)
		return -EINVAL;

	if (fstat(devfd, &st) < 0)
		goto out;

	if (S_ISREG(st.st_mode)) {
		*size = (uint64_t)st.st_size;
        log_dbg("st size: %llu", *size);
		r = 0;
	} else if (ioctl(devfd, BLKGETSIZE64, size) >= 0) {
        log_dbg("ioctl size: %llu", *size);
		r = 0;
    }
out:
	close(devfd);
	return r;
}
コード例 #20
0
static void max14688_irq_button_pressed (struct max14688 *me)
{
    int micZ;

    /* Make sure no button down */
    max14688_irq_button_released(me);

    /* Read MIC impedences */
    micZ = me->read_mic_impedence(me->dev);

    /* Look up button matching impedence ranges */
    max14688_lookup_button(me, micZ);

    log_dbg("%s[micZ = %d]\n", __func__, micZ);

    if (unlikely(!__present_valid_button(me))) {
	    log_warn("unknown button - mic %d\n", micZ);
	    goto out;
    }

    log_dbg("button %s pressed\n", __current_button_name(me));
    me->report_button(me->dev, __current_button(me), BUTTON_DOWN_VALUE);

out:
    return;
}
コード例 #21
0
static int max14688_read_left_impedence (struct device *dev)
{
    struct max14688 *me = dev_get_drvdata(dev);
    u8 adcconversion = 0;
    u8 adcstatus = 0;

    int rc;

    rc = max14688_read(me, ADCCONVERSION, &adcconversion);
    if (unlikely(rc)) {
	    log_err("ADCCONVERSION read error [%d]\n", rc);
	    goto out;
    }

    log_dbg("%s[adc value = %d]\n", __func__, adcconversion);

    /* Greater than 2.69k(ohm) resistor is connected, read the EOC bit in the ADCSTATUS address */
    max14688_read(me, ADCSTATUS, &adcstatus);
    if (!(BITS_GET(adcstatus, ADCSTATUS_EOC))) {
	    log_dbg("%s[ADC_VAL_MAX = %d]\n", __func__, (int)ADC_VAL_MAX);
	    rc = (int)ADC_VAL_MAX;
    } else {
	    rc = (int)adcconversion;
    }
out:
    return rc;
}
コード例 #22
0
/*
 * Sanity checks before checksum is validated
 */
static int hdr_disk_sanity_check_pre(struct luks2_hdr_disk *hdr,
				     size_t *hdr_json_size, int secondary,
				     uint64_t offset)
{
	if (memcmp(hdr->magic, secondary ? LUKS2_MAGIC_2ND : LUKS2_MAGIC_1ST, LUKS2_MAGIC_L))
		return -EINVAL;

	if (be16_to_cpu(hdr->version) != 2) {
		log_dbg("Unsupported LUKS2 header version %u.", be16_to_cpu(hdr->version));
		return -EINVAL;
	}

	if (offset != be64_to_cpu(hdr->hdr_offset)) {
		log_dbg("LUKS2 offset 0x%04x on device differs to expected offset 0x%04x.",
			(unsigned)be64_to_cpu(hdr->hdr_offset), (unsigned)offset);
		return -EINVAL;
	}

	/* FIXME: sanity check checksum alg. */

	log_dbg("LUKS2 header version %u of size %u bytes, checksum %s.",
		(unsigned)be16_to_cpu(hdr->version), (unsigned)be64_to_cpu(hdr->hdr_size),
		hdr->checksum_alg);

	*hdr_json_size = be64_to_cpu(hdr->hdr_size) - LUKS2_HDR_BIN_LEN;
	return 0;
}
コード例 #23
0
ファイル: garden.c プロジェクト: kernel-digger/coova-chilli
int pass_through_add(pass_through * ptlist, uint32_t ptlen,
		     uint32_t * ptcnt, pass_through * pt, char is_dyn
#ifdef HAVE_PATRICIA
		     , patricia_tree_t * ptree
#endif
    )
{
	uint32_t cnt = *ptcnt;
	int i;

	for (i = 0; i < cnt; i++) {
		if (pt_equal(&ptlist[i], pt)) {
			log_dbg
			    ("Uamallowed already exists #%d:%d: proto=%d host=%s port=%d",
			     i, ptlen, pt->proto, inet_ntoa(pt->host),
			     pt->port);
			if (is_dyn) {
				log_dbg("Shifting uamallowed list %d to %d", i,
					cnt);
				for (; i < cnt - 1; i++)
					memcpy(&ptlist[i], &ptlist[i + 1],
					       sizeof(pass_through));
				cnt = *ptcnt = *ptcnt - 1;
				break;
			} else {
				return 0;
			}
		}
	}

	if (cnt == ptlen) {
		if (!is_dyn) {
			log_dbg("No more room for walled garden entries");
			return -1;
		}

		log_dbg("Shifting uamallowed list %d to %d", i, ptlen);
		for (i = 0; i < ptlen - 1; i++)
			memcpy(&ptlist[i], &ptlist[i + 1],
			       sizeof(pass_through));

		cnt = *ptcnt = *ptcnt - 1;
	}

	log_dbg("Uamallowed IP address #%d:%d: proto=%d host=%s port=%d",
		cnt, ptlen, pt->proto, inet_ntoa(pt->host), pt->port);

	memcpy(&ptlist[cnt], pt, sizeof(pass_through));
	*ptcnt = cnt + 1;

#ifdef HAVE_PATRICIA
	if (ptree)
		garden_patricia_add(pt, ptree);
#endif

	return 0;
}
コード例 #24
0
static void max14688_det_work (struct work_struct *work)
{
    struct max14688 *me = container_of(work, struct max14688, det_work.work);
    int micZ, leftZ;

    if(earjack_detect == true) {
	    log_dbg("duplication intterupt already connect earjack\n");
	    return;
    } else {
	    earjack_detect = true;
    }

    __lock(me);

    if (unlikely(!me->detect_jack(me->dev))) {
	    log_warn("no jack in detection work\n");
	    earjack_detect = false;
	    goto out;
    }

    max14688_update_status(me);

    /* Read MIC and L-line impedences */
    micZ  = me->read_mic_impedence(me->dev);
    leftZ = me->read_left_impedence(me->dev);

    log_dbg("%s[micZ = %d, leftZ = %d\n", __func__, micZ, leftZ);

    /* Look up jack matching impedence ranges */
    max14688_lookup_jack(me, micZ, leftZ);

    if (unlikely(!__present_valid_jack(me))) {
	    earjack_detect = false;
	    goto no_match_found;
    }

    max14688_write_mode0(me, __current_jack_mode0(me));
    max14688_write_mode1(me, __current_jack_mode1(me));

    if (__current_jack_has_button(me)) {
	    max14688_enable_irq(me, IRQ_SWD);
    } else {
	    max14688_disable_irq(me, IRQ_SWD);
    }

    log_dbg("jack %s inserted\n", __current_jack_name(me));
    me->report_jack(me->dev, __current_jack(me), JACK_IN_VALUE);
    goto out;

no_match_found:
    /* Handle exception */
    log_err("unknown jack - mic %d, left %d\n", micZ, leftZ);

out:
    __unlock(me);
    return;
}
コード例 #25
0
ファイル: tcrypt.c プロジェクト: kriswebdev/cryptsetup-deluks
static int TCRYPT_hdr_from_disk(struct tcrypt_phdr *hdr,
				struct crypt_params_tcrypt *params,
				int kdf_index, int cipher_index)
{
	uint32_t crc32;
	size_t size;

	/* Check CRC32 of header */
	size = TCRYPT_HDR_LEN - sizeof(hdr->d.keys) - sizeof(hdr->d.header_crc32);
	crc32 = crypt_crc32(~0, (unsigned char*)&hdr->d, size) ^ ~0;
	if (be16_to_cpu(hdr->d.version) > 3 &&
	    crc32 != be32_to_cpu(hdr->d.header_crc32)) {
		log_dbg("TCRYPT header CRC32 mismatch.");
		return -EINVAL;
	}

	/* Check CRC32 of keys */
	crc32 = crypt_crc32(~0, (unsigned char*)hdr->d.keys, sizeof(hdr->d.keys)) ^ ~0;
	if (crc32 != be32_to_cpu(hdr->d.keys_crc32)) {
		log_dbg("TCRYPT keys CRC32 mismatch.");
		return -EINVAL;
	}

	/* Convert header to cpu format */
	hdr->d.version  =  be16_to_cpu(hdr->d.version);
	hdr->d.version_tc = be16_to_cpu(hdr->d.version_tc);

	hdr->d.keys_crc32 = be32_to_cpu(hdr->d.keys_crc32);

	hdr->d.hidden_volume_size = be64_to_cpu(hdr->d.hidden_volume_size);
	hdr->d.volume_size        = be64_to_cpu(hdr->d.volume_size);

	hdr->d.mk_offset = be64_to_cpu(hdr->d.mk_offset);
	if (!hdr->d.mk_offset)
		hdr->d.mk_offset = 512;

	hdr->d.mk_size = be64_to_cpu(hdr->d.mk_size);

	hdr->d.flags = be32_to_cpu(hdr->d.flags);

	hdr->d.sector_size = be32_to_cpu(hdr->d.sector_size);
	if (!hdr->d.sector_size)
		hdr->d.sector_size = 512;

	hdr->d.header_crc32 = be32_to_cpu(hdr->d.header_crc32);

	/* Set params */
	params->passphrase = NULL;
	params->passphrase_size = 0;
	params->hash_name  = tcrypt_kdf[kdf_index].hash;
	params->key_size = tcrypt_cipher[cipher_index].chain_key_size;
	params->cipher = tcrypt_cipher[cipher_index].long_name;
	params->mode = tcrypt_cipher[cipher_index].mode;

	return 0;
}
コード例 #26
0
ファイル: preferences.c プロジェクト: SRI-CSL/jumpbox
static void
prf_set(httpsrv_client_t *hcl) {

	if (hcl->readbody == NULL) {
		if (hcl->headers.content_length == 0) {
			djb_error(hcl, 400,
				  "Setting preferences requires a length");
			return;
		}

		if (httpsrv_readbody_alloc(hcl, 0, 0) < 0) {
			log_wrn("httpsrv_readbody_alloc() failed");
		}

		/* Let httpsrv read */
		return;
	}

	log_dbg("prefs = %s", hcl->readbody);

	mutex_lock(l_mutex);

	if (l_current_preferences != NULL)
		free(l_current_preferences); 

	l_current_preferences = (hcl->readbody == NULL ? NULL : strdup(hcl->readbody));
	if (prf_parse_preferences()) {
#if DEBUGHANDLE
		/* this block is just for testing */
		unsigned int	argc = 0, i;
		char		**argv = NULL;

		for (i = 0; i < PRF_MAX; i++) {
			if (l_keys[i] == NULL)
				continue;

			if (l_values[i] == NULL)
				continue;

			log_dbg("%s => %s\n", l_keys[i], l_values[i]);
		}

		argc = prf_get_argv(&argv);
		log_wrn("argc = %u", argc);
		for (i = 0; i < argc; i++) {
			log_dbg("argv[%u] = %s\n", i, argv[i]);
		}
#endif
		djb_result(hcl, DJB_OK, "Preferences OK");
	} else {
		djb_result(hcl, DJB_OK, "Preferences broken");
	}

	mutex_unlock(l_mutex);
}
コード例 #27
0
ファイル: rendezvous.c プロジェクト: SRI-CSL/jumpbox
static const char *
rdv_peel_captcha_no_image_path(void) {
	int		retcode;
	const char	*path, *ret;

	fassert(l_current_image_dir != NULL);

	l_captcha_image_path =
		aprintf("%s" PATH_SEPARATOR "captcha.png",
			l_current_image_dir);
	if (l_captcha_image_path == NULL) {
		return (NULL);
	}

	log_dbg("Captcha image = %s",
		l_captcha_image_path);

	retcode = bytes2file(l_captcha_image_path,
			     ONION_PUZZLE_SIZE(l_current_onion),
			     ONION_PUZZLE(l_current_onion));

	if (retcode != DEFIANT_OK) {
		log_dbg("Could not store captcha to %s: %s",
			l_captcha_image_path,
			defiant_strerror(retcode));

		/* Failed, thus clean up */
		aprintf_free(l_captcha_image_path);
		l_captcha_image_path = NULL;

		return (NULL);
	}

	path = aprintf(
		"/rendezvous/file%s",
		l_captcha_image_path);
	if (path == NULL) {
		ret = NULL;
	} else {
		/* Our captcha image */
		ret = rdv_make_peel_response(path, "Here is your captcha image!");

		/* Free temporary path */
		aprintf_free(path);
	}

	if (ret == NULL) {
		/* Failed, thus clean up */
		aprintf_free(l_captcha_image_path);
		l_captcha_image_path = NULL;
	}

	return (ret);
}
コード例 #28
0
ファイル: libdevmapper.c プロジェクト: AhmadTux/DragonFlyBSD
static void _dm_set_crypt_compat(int maj, int min, int patch)
{
	log_dbg("Detected dm-crypt target of version %i.%i.%i.", maj, min, patch);

	if (maj >= 1 && min >=2)
		_dm_crypt_wipe_key_supported = 1;
	else
		log_dbg("Suspend and resume disabled, no wipe key support.");

	_dm_crypt_checked = 1;
}
コード例 #29
0
ファイル: utils.c プロジェクト: murali-marimekala/cryptsetup
int crypt_memlock_dec(struct crypt_device *ctx)
{
	if (_memlock_count && (!--_memlock_count)) {
		log_dbg("Unlocking memory.");
		if (munlockall() == -1)
			log_err(ctx, _("Cannot unlock memory."));
		if (setpriority(PRIO_PROCESS, 0, _priority))
			log_dbg("setpriority %d failed: %s", _priority, strerror(errno));
	}
	return _memlock_count ? 1 : 0;
}
コード例 #30
0
ファイル: tcrypt.c プロジェクト: kriswebdev/cryptsetup-deluks
static int TCRYPT_decrypt_hdr(struct crypt_device *cd, struct tcrypt_phdr *hdr,
			       const char *key, uint32_t flags)
{
	struct tcrypt_phdr hdr2;
	int i, j, r = -EINVAL;

	for (i = 0; tcrypt_cipher[i].chain_count; i++) {
		if (!(flags & CRYPT_TCRYPT_LEGACY_MODES) && tcrypt_cipher[i].legacy)
			continue;
		log_dbg("TCRYPT:  trying cipher %s-%s",
			tcrypt_cipher[i].long_name, tcrypt_cipher[i].mode);

		memcpy(&hdr2.e, &hdr->e, TCRYPT_HDR_LEN);

		if (!strncmp(tcrypt_cipher[i].mode, "cbci", 4))
			r = TCRYPT_decrypt_cbci(&tcrypt_cipher[i], key, &hdr2);
		else for (j = tcrypt_cipher[i].chain_count - 1; j >= 0 ; j--) {
			if (!tcrypt_cipher[i].cipher[j].name)
				continue;
			r = TCRYPT_decrypt_hdr_one(&tcrypt_cipher[i].cipher[j],
					    tcrypt_cipher[i].mode, key, &hdr2);
			if (r < 0)
				break;
		}

		if (r < 0) {
			log_dbg("TCRYPT:   returned error %d, skipped.", r);
			if (r == -ENOTSUP)
				break;
			r = -ENOENT;
			continue;
		}

		if (!strncmp(hdr2.d.magic, TCRYPT_HDR_MAGIC, TCRYPT_HDR_MAGIC_LEN)) {
			log_dbg("TCRYPT: Signature magic detected.");
			memcpy(&hdr->e, &hdr2.e, TCRYPT_HDR_LEN);
			r = i;
			break;
		}
		if ((flags & CRYPT_TCRYPT_VERA_MODES) &&
		     !strncmp(hdr2.d.magic, VCRYPT_HDR_MAGIC, TCRYPT_HDR_MAGIC_LEN)) {
			log_dbg("TCRYPT: Signature magic detected (Veracrypt).");
			memcpy(&hdr->e, &hdr2.e, TCRYPT_HDR_LEN);
			r = i;
			break;
		}
		r = -EPERM;
	}

	crypt_memzero(&hdr2, sizeof(hdr2));
	return r;
}