コード例 #1
0
ファイル: bif_crypto.c プロジェクト: aidanhs/teeterl
term_t bif_rc4_init1(term_t Key, process_t *ctx)
{
	apr_byte_t *s;
	apr_byte_t i, j;
	apr_byte_t key_len;
	apr_byte_t *key_data;

	if (!is_binary(Key))
		return A_BADARG;
	s = xalloc(proc_gc_pool(ctx), 256+2);	//2 for i and j
	key_len = (apr_byte_t)int_value(bin_size(Key));
	key_data = bin_data(Key);

	i = 0;
	do {
		s[i] = i++;
	} while (i != 0);
	
	i = j = 0;
	do {
		apr_byte_t temp;
		j += key_data[i%key_len]+s[i];
		temp = s[i];
		s[i] = s[j];
		s[j] = temp;
		i++;
	} while (i != 0);

	s[256] = 0;
	s[257] = 0;

	result(make_binary(intnum(256+2), s, proc_gc_pool(ctx)));
	return AI_OK;
}
コード例 #2
0
ファイル: autocomplete.c プロジェクト: Yopes/42sh
char		*autocomplete(int *index, char *str, t_cmd *cmd)
{
  int		star;
  t_bin		*bin;
  int		size;

  if (isatty(0) == 0)
    return (str);
  star = contain_star(&str[*index]);
  if (!(bin = xmalloc(sizeof(*bin))))
    return (str);
  bin->next = NULL;
  if (is_first_word(str, *index) == 1 && str[0] != '.')
    {
      if (auto_binaries(cmd, str, bin) == -1)
	return (str);
    }
  else if (auto_file(str, index, bin, star) == -1)
    return (str);
  size = bin_size(bin);
  print_possibilities_or_not(bin, size);
  while (str[*index] != '\0' && str[*index] != ' ' && str[*index] != '\t')
    *index = *index + 1;
  if ((size > 0 && star == 0) || size == 1)
    str = autocomplete_replace(str, bin, index, cmd);
  replace_index(str, cmd, bin, index);
  return (str);
}
コード例 #3
0
ファイル: ibex_Expr.cpp プロジェクト: nicolaje/IBEX
ExprBinaryOp::ExprBinaryOp(const ExprNode& left, const ExprNode& right, const Dim& dim) :
		ExprNode(	max_height(left,right)+1,
					bin_size(left,right),
					dim ),
		left(left), right(right) {

	((ExprNode&) left).fathers.add(*this);
	((ExprNode&) right).fathers.add(*this);
}
コード例 #4
0
ファイル: bif_crypto.c プロジェクト: aidanhs/teeterl
term_t bif_md5_1(term_t Data, process_t *ctx)
{
	apr_byte_t *digest = xalloc(proc_gc_pool(ctx), MD5_DIGESTSIZE);
	if (!is_binary(Data))
		return A_BADARG;
	md5(digest, bin_data(Data), (apr_size_t)int_value(bin_size(Data)));
	result(make_binary(intnum(MD5_DIGESTSIZE), digest, proc_gc_pool(ctx)));
	return AI_OK;
}
コード例 #5
0
ファイル: bif_crypto.c プロジェクト: aidanhs/teeterl
term_t bif_md5_update2(term_t Data, term_t Context, process_t *ctx)
{
	apr_size_t size;
	md5_ctx_t *tmp;
	if (!is_binary(Data) || !is_binary(Context))
		return A_BADARG;
	if (int_value2(bin_size(Context)) != sizeof(md5_ctx_t))
		return A_BADARG;
	size = (apr_size_t)int_value(bin_size(Data));
	
	tmp = xalloc(proc_gc_pool(ctx), sizeof(*tmp));
	memcpy(tmp, bin_data(Context), sizeof(*tmp));
	
	md5_update(tmp, bin_data(Data), size);
	result(make_binary(intnum(sizeof(*tmp)),
		(apr_byte_t *)tmp, proc_gc_pool(ctx)));
	return AI_OK;
}
コード例 #6
0
ファイル: ibex_Expr.cpp プロジェクト: nicolaje/reliable-slam
ExprBinaryOp::ExprBinaryOp(const ExprNode& left, const ExprNode& right, const Dim& dim) :
		ExprNode(	max_height(left,right)+1,
					bin_size(left,right),
					dim ),
		left(left), right(right) {

	((ExprNode*&) left.father)=this;
	((ExprNode*&) right.father)=this;
}
コード例 #7
0
ファイル: bif_crypto.c プロジェクト: aidanhs/teeterl
term_t bif_rc4_update2(term_t Text, term_t Opaque, process_t *ctx)
{
	apr_byte_t *text_data;
	apr_uint32_t text_size, k;
	apr_byte_t *s;
	apr_byte_t i, j;
	term_t Text1, Opaque1;

	if (!is_binary(Text) || !is_binary(Opaque) || bin_size(Opaque) != intnum(256+2))
		return A_BADARG;

	text_size = int_value2(bin_size(Text));
	text_data = xalloc(proc_gc_pool(ctx), text_size);
	memcpy(text_data, bin_data(Text), text_size);
	
	s = xalloc(proc_gc_pool(ctx), 256+2);
	memcpy(s, bin_data(Opaque), 256+2);

	i = s[256];
	j = s[257];

	for (k = 0; k < text_size; k++)
	{
		apr_byte_t temp;
		i++;
		j += s[i];
		temp = s[i];
		s[i] = s[j];
		s[j] = temp;

		text_data[k] ^= s[(s[i]+s[j]) & 255];
	}

	s[256] = i;
	s[257] = j;

	Text1 = make_binary(intnum(text_size), text_data, proc_gc_pool(ctx));
	Opaque1 = make_binary(intnum(256+2), s, proc_gc_pool(ctx));

	result(make_tuple2(Text1, Opaque1, proc_gc_pool(ctx)));
	return AI_OK;
}
コード例 #8
0
ファイル: bif_crypto.c プロジェクト: aidanhs/teeterl
term_t bif_md5_final1(term_t Context, process_t *ctx)
{
	apr_byte_t *data;
	if (!is_binary(Context) ||
			int_value2(bin_size(Context)) != sizeof(md5_ctx_t))
		return A_BADARG;
	data = xalloc(proc_gc_pool(ctx), 16);
	md5_final(data, (md5_ctx_t *)bin_data(Context));
	result(make_binary(intnum(MD5_DIGESTSIZE), data, proc_gc_pool(ctx)));
	return AI_OK;
}
コード例 #9
0
ファイル: bif_file.c プロジェクト: aidanhs/teeterl
term_t bif_write0_2(term_t Port, term_t Bin, process_t *ctx)
{
	apr_status_t rs;
	apr_size_t size;
	port_t *p;
	if (!is_port(Port) || !is_binary(Bin))
		return A_BADARG;
	p = port_lookup(prp_serial(Port));
	if (p == 0)
		return A_BADARG;
	size = (apr_size_t)int_value(bin_size(Bin));
	rs = p->write(p, bin_data(Bin), &size);
	if (rs != 0)
		return decipher_status(rs); //TODO: something may still be written
	result(intnum(size));
	return AI_OK;
}
コード例 #10
0
ファイル: bif_gen_udp.c プロジェクト: aidanhs/teeterl
term_t bif_sendto4(term_t Sock, term_t RemIP, term_t RemPort, term_t Bin, process_t *ctx)
{
	apr_status_t rs;
	port_t *port;
	apr_socket_t *sock;
	const char *host;
	int udp_port;
	apr_sockaddr_t *sa;
	apr_pool_t *p;

	if (!is_port(Sock))
		return A_BADARG;
	if (!is_binary(RemIP) || !is_int(RemPort))
		return A_BADARG;
	if (!is_binary(Bin))
		return A_BADARG;

	port = port_lookup(prp_serial(Sock));
	if (port == 0)
		return A_CLOSED;
	if (!port->is_socket(port))
		return A_BADARG;
	sock = port->get_socket(port);

	host = (const char *)bin_data(RemIP);
	udp_port = (apr_port_t)int_value(RemPort);

	apr_pool_create(&p, 0);
	rs = apr_sockaddr_info_get(&sa, host, APR_INET, udp_port, 0, p);
	if (rs == 0)
	{
		apr_size_t len = (apr_size_t)int_value(bin_size(Bin));
		rs = apr_socket_sendto(sock, sa, 0, (const char *)bin_data(Bin), &len);
	}

	if (rs != 0)
	{
		apr_pool_destroy(p);
		return decipher_status(rs);
	}

	result(A_OK);
	return AI_OK;
}
コード例 #11
0
ファイル: port_socket.c プロジェクト: aidanhs/teeterl
static apr_status_t port_buffer_send(buffer_t *buf, term_t io)
{
	int avail;

	if (is_nil(io))
		return 0;

	avail = buffer_available(buf);
	if (is_int(io))
	{
		if (avail == 0)
			return APR_EINCOMPLETE;
		else
			buffer_put_byte(buf, int_value(io));
	}
	else if (is_binary(io))
	{
		int size = int_value2(bin_size(io));
		if (size > avail)
		{
			buffer_put_data(buf, bin_data(io), avail);
			return APR_EINCOMPLETE;
		}
		else
			buffer_put_data(buf, bin_data(io), size);
	}
	if (is_list(io))
	{
		while (is_cons(io))
		{
			apr_status_t rs;
			rs = port_buffer_send(buf, lst_value(io));
			if (rs != 0)
				return rs;
			io = lst_next(io);
		}
	}

	return APR_SUCCESS;
}
コード例 #12
0
ファイル: SourceFile.cpp プロジェクト: hleclerc/Stela
int SourceFile::tot_size() const {
    return sizeof( int ) + bin_size() + sizeof( int ) + str_size() + 1;
}
コード例 #13
0
ファイル: SourceFile.cpp プロジェクト: hleclerc/Stela
int SourceFile::str_size() const {
    return *reinterpret_cast<const int *>( ptr + sizeof( int ) + bin_size() );
}
コード例 #14
0
ファイル: SourceFile.cpp プロジェクト: hleclerc/Stela
const char *SourceFile::filename() const{
    return reinterpret_cast<const char *>( ptr + sizeof( int ) + bin_size() + sizeof( int ) );
}
コード例 #15
0
ファイル: cell.c プロジェクト: racemidev/RegAdminForLinux
gboolean
hcheck_cell_pass(Hive *in_hive, RRACheckData *in_data)
{
    if (in_hive == NULL)
    {
        return FALSE;
    }

    gboolean ret_val = TRUE;

    Bin *b;
    for (b = hive_get_first_bin(in_hive);
         b != NULL;
         b = bin_get_next_bin(b))
    {
        offset end_of_bin = offset_make_relative(bin_get_offset(b),
                                                 bin_size(b) - 1);
        if (offset_to_begin (end_of_bin) == 0)
        {
            rra_check_warning(
                in_data,
                _("Bad end offset for end of bin from: %d and %d"),
                bin_get_offset(b), bin_size(b));
            bin_debug_print(b, TRUE);
        }

        Cell *last_c = NULL;
        Cell *c;
        for (c = bin_first_cell(b);
             c != NULL;
             last_c = c, c = cell_get_next(c))
        {
            rra_check_checking(in_data, _("valid size"));
            if (cell_size(c) < sizeof(guint32) * 2)
            {
                rra_check_error(in_data,
                                _("invalid cell size: %d"),
                                cell_size(c));
                ret_val = FALSE;
            }

            rra_check_checking(in_data, _("last cell correct"));
            if (cell_get_prev(c) != last_c)
            {
                rra_check_error(in_data,
                                _("last cell incorrect"));
                ret_val = FALSE;
            }

            rra_check_checking(in_data, _("cell stays within bin"));
            offset end_of_cell = offset_make_relative(cell_get_offset(c),
                                                      cell_size(c) - 1);
            int cmp_val = offset_compare(end_of_bin, end_of_cell);
            if (cmp_val < 0)
            {
                rra_check_error(
                    in_data,
                    _("cell extends past end of bin: "
                      "Bin(%d) vs Cell(%d) => %d"),
                    offset_to_begin(end_of_bin),
                    offset_to_begin(end_of_cell),
                    cmp_val);
                ret_val = FALSE;
            }
        }
    }

    return TRUE;
}