예제 #1
0
static int parse_ip6_class(int *argc_p, char ***argv_p, struct tc_u32_sel *sel)
{
	int res = -1;
	int argc = *argc_p;
	char **argv = *argv_p;
	__u32 key;
	__u32 mask;
	int off = 0;
	int offmask = 0;

	if (argc < 2)
		return -1;

	if (get_u32(&key, *argv, 0))
		return -1;
	argc--; argv++;

	if (get_u32(&mask, *argv, 16))
		return -1;
	argc--; argv++;

	if (key > 0xFF || mask > 0xFF)
		return -1;

	key <<= 20;
	mask <<= 20;
	key = htonl(key);
	mask = htonl(mask);

	res = pack_key(sel, key, mask, off, offmask);
	if (res < 0)
		return -1;

	*argc_p = argc;
	*argv_p = argv;
	return 0;
}
예제 #2
0
static int qfq_parse_class_opt(struct qdisc_util *qu, int argc, char **argv,
			       struct nlmsghdr *n)
{
	struct rtattr *tail;
	__u32 tmp;

	tail = NLMSG_TAIL(n);
	addattr_l(n, 4096, TCA_OPTIONS, NULL, 0);

	while (argc > 0) {
		if (matches(*argv, "weight") == 0) {
			NEXT_ARG();
			if (get_u32(&tmp, *argv, 10)) {
				explain1("weight"); return -1;
			}
			addattr32(n, 4096, TCA_QFQ_WEIGHT, tmp);
		} else if (matches(*argv, "maxpkt") == 0) {
			NEXT_ARG();
			if (get_u32(&tmp, *argv, 10)) {
				explain1("maxpkt"); return -1;
			}
			addattr32(n, 4096, TCA_QFQ_LMAX, tmp);
		} else if (strcmp(*argv, "help") == 0) {
			explain_class();
			return -1;
		} else {
			fprintf(stderr, "What is \"%s\"?\n", *argv);
			explain_class();
			return -1;
		}
		argc--; argv++;
	}

	tail->rta_len = (void *)NLMSG_TAIL(n) - (void *)tail;

	return 0;
}
예제 #3
0
static int labx_local_audio_of_probe(struct of_device *ofdev, const struct of_device_id *match)
{
  struct resource r_mem_struct;
  struct resource *addressRange = &r_mem_struct;
  struct platform_device *pdev = to_platform_device(&ofdev->dev);
  const char *interfaceType;
  u32 numChannels;
  int ret;
  u32 has_serializer;
  
  /* Obtain the resources for this instance; use the device tree node name */
  const char *name = ofdev->node->name;
  ret = of_address_to_resource(ofdev->node, 0, addressRange);
  if (ret) {
    dev_warn(&ofdev->dev, "Invalid address\n");
    return(ret);
  }

  /* Look up the number of channels in the device tree */
  numChannels = (get_u32(ofdev, "xlnx,num-i2s-streams") * 2);

  /* Check the interface type to see if a DMA exists */
  has_serializer = get_u32(ofdev, "xlnx,has-serializer");
  if (has_serializer)
    interfaceType = (char *) of_get_property(ofdev->node, "xlnx,interface-type", NULL);
  else
    interfaceType = LA_DMA_INTERFACE_EXTERNAL;
  
  if(interfaceType == NULL) {
    dev_warn(&ofdev->dev, "labx_local_audio : (%s) No interface type defined\n", name);
    return(-1);
  }

  /* Dispatch to the generic function */
  return(labx_local_audio_probe(name, pdev, addressRange, interfaceType, numChannels, NULL, NULL, NULL));
}
예제 #4
0
static int xfrm_seq_parse(__u32 *seq, int *argcp, char ***argvp)
{
	int argc = *argcp;
	char **argv = *argvp;

	if (get_u32(seq, *argv, 0))
		invarg("\"SEQ\" is invalid", *argv);

	*seq = htonl(*seq);

	*argcp = argc;
	*argvp = argv;

	return 0;
}
예제 #5
0
파일: q_ccnsfq.c 프로젝트: pviotti/ccnsfq
static int ccnsfq_parse_opt(struct qdisc_util *qu, int argc, char **argv, struct nlmsghdr *n)
{
	int ok=0;
	struct tc_ccnsfq_qopt opt;

	memset(&opt, 0, sizeof(opt));

	while (argc > 0) {
		if (strcmp(*argv, "quantum") == 0) {
			NEXT_ARG();
			if (get_size(&opt.quantum, *argv)) {
				fprintf(stderr, "Illegal \"limit\"\n");
				return -1;
			}
			ok++;
		} else if (strcmp(*argv, "perturb") == 0) {
			NEXT_ARG();
			if (get_integer(&opt.perturb_period, *argv, 0)) {
				fprintf(stderr, "Illegal \"perturb\"\n");
				return -1;
			}
			ok++;
		} else if (strcmp(*argv, "limit") == 0) {
			NEXT_ARG();
			if (get_u32(&opt.limit, *argv, 0)) {
				fprintf(stderr, "Illegal \"limit\"\n");
				return -1;
			}
			if (opt.limit < 2) {
				fprintf(stderr, "Illegal \"limit\", must be > 1\n");
				return -1;
			}
			ok++;
		} else if (strcmp(*argv, "help") == 0) {
			explain();
			return -1;
		} else {
			fprintf(stderr, "What is \"%s\"?\n", *argv);
			explain();
			return -1;
		}
		argc--; argv++;
	}

	if (ok)
		addattr_l(n, 1024, TCA_OPTIONS, &opt, sizeof(opt));
	return 0;
}
예제 #6
0
파일: ipseg6.c 프로젝트: 6WIND/iproute2
int do_seg6(int argc, char **argv)
{
	if (argc < 1 || matches(*argv, "help") == 0)
		usage();

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

	if (matches(*argv, "hmac") == 0) {
		NEXT_ARG();
		if (matches(*argv, "show") == 0) {
			opts.cmd = SEG6_CMD_DUMPHMAC;
		} else if (matches(*argv, "set") == 0) {
			NEXT_ARG();
			if (get_u32(&opts.keyid, *argv, 0) || opts.keyid == 0)
				invarg("hmac KEYID value is invalid", *argv);
			NEXT_ARG();
			if (strcmp(*argv, "sha1") == 0) {
				opts.alg_id = SEG6_HMAC_ALGO_SHA1;
			} else if (strcmp(*argv, "sha256") == 0) {
				opts.alg_id = SEG6_HMAC_ALGO_SHA256;
			} else {
				invarg("hmac ALGO value is invalid", *argv);
			}
			opts.cmd = SEG6_CMD_SETHMAC;
			opts.pass = getpass(HMAC_KEY_PROMPT);
		} else {
			invarg("unknown", *argv);
		}
	} else if (matches(*argv, "tunsrc") == 0) {
		NEXT_ARG();
		if (matches(*argv, "show") == 0) {
			opts.cmd = SEG6_CMD_GET_TUNSRC;
		} else if (matches(*argv, "set") == 0) {
			NEXT_ARG();
			opts.cmd = SEG6_CMD_SET_TUNSRC;
			if (!inet_get_addr(*argv, NULL, &opts.addr))
				invarg("tunsrc ADDRESS value is invalid",
				       *argv);
		} else {
			invarg("unknown", *argv);
		}
	} else {
		invarg("unknown", *argv);
	}

	return seg6_do_cmd();
}
int get_u32_handle(__u32 *handle, char *str)
{
	__u32 htid=0, hash=0, nodeid=0;
	char *tmp = strchr(str, ':');

	if (tmp == NULL) {
		if (memcmp("0x", str, 2) == 0)
			return get_u32(handle, str, 16);
		return -1;
	}
	htid = strtoul(str, &tmp, 16);
	if (tmp == str && *str != ':' && *str != 0)
		return -1;
	//if (htid>=0x1000)
	//	return -1;
	//if (htid>=0xFFFF)
	//	return -1;
	if (htid>=0x1000)//richie1124
		return -1;
	if (*tmp) {
		str = tmp+1;
		hash = strtoul(str, &tmp, 16);
fprintf(stderr, "1 get_u32_handle: hash[%x]\n",hash);
		if (tmp == str && *str != ':' && *str != 0)
			return -1;
		//if (hash>=0x100)//richie1124
		//	return -1;
		if (hash>=0x1000)
			return -1;
		if (*tmp) {
			str = tmp+1;
			nodeid = strtoul(str, &tmp, 16);
			if (tmp == str && *str != 0)
				return -1;
 			//if (nodeid>=0x1000)//richie1124
 			//	return -1;
 			if (nodeid>=0x100)
				return -1;
		}
	}
	//fprintf(stderr, "get_u32_handle: htid[%x], hash[%x], nodeid[%x]\n",htid, hash, nodeid);
	//*handle = (htid<<20)|(hash<<12)|nodeid;
	//*handle = (htid<<16)|(hash<<8)|nodeid;
	*handle = (htid<<20)|(hash<<8)|nodeid;//richie1124
	return 0;
}
예제 #8
0
static int
ssh_request_reply(AuthenticationConnection *auth, Buffer *request, Buffer *reply)
{
	u_int l, len;
	char buf[1024];

	/* Get the length of the message, and format it in the buffer. */
	len = buffer_len(request);
	put_u32(buf, len);

	/* Send the length and then the packet to the agent. */
	if (atomicio(vwrite, auth->fd, buf, 4) != 4 ||
	    atomicio(vwrite, auth->fd, buffer_ptr(request),
	    buffer_len(request)) != buffer_len(request)) {
		error("Error writing to authentication socket.");
		return 0;
	}
	/*
	 * Wait for response from the agent.  First read the length of the
	 * response packet.
	 */
	if (atomicio(read, auth->fd, buf, 4) != 4) {
	    error("Error reading response length from authentication socket.");
	    return 0;
	}

	/* Extract the length, and check it for sanity. */
	len = get_u32(buf);
	if (len > 256 * 1024)
		fatal("Authentication response too long: %u", len);

	/* Read the rest of the response in to the buffer. */
	buffer_clear(reply);
	while (len > 0) {
		l = len;
		if (l > sizeof(buf))
			l = sizeof(buf);
		if (atomicio(read, auth->fd, buf, l) != l) {
			error("Error reading response from authentication socket.");
			return 0;
		}
		buffer_append(reply, buf, l);
		len -= l;
	}
	return 1;
}
예제 #9
0
파일: m_pedit.c 프로젝트: eworm-de/iproute2
static int parse_val(int *argc_p, char ***argv_p, __u32 *val, int type)
{
	int argc = *argc_p;
	char **argv = *argv_p;

	if (argc <= 0)
		return -1;

	if (type == TINT)
		return get_integer((int *)val, *argv, 0);

	if (type == TU32)
		return get_u32(val, *argv, 0);

	if (type == TIPV4) {
		inet_prefix addr;

		if (get_prefix_1(&addr, *argv, AF_INET))
			return -1;

		*val = addr.data[0];
		return 0;
	}

	if (type == TIPV6) {
		inet_prefix addr;

		if (get_prefix_1(&addr, *argv, AF_INET6))
			return -1;

		memcpy(val, addr.data, addr.bytelen);

		return 0;
	}

	if (type == TMAC) {
#define MAC_ALEN 6
		int ret = ll_addr_a2n((char *)val, MAC_ALEN, *argv);

		if (ret == MAC_ALEN)
			return 0;
	}

	return -1;
}
예제 #10
0
파일: tc.c 프로젝트: hvoigt/iproute2
static int parse_nofopt(struct filter_util *qu, char *fhandle, int argc, char **argv, struct nlmsghdr *n)
{
	__u32 handle;

	if (argc) {
		fprintf(stderr, "Unknown filter \"%s\", hence option \"%s\" is unparsable\n", qu->id, *argv);
		return -1;
	}
	if (fhandle) {
		struct tcmsg *t = NLMSG_DATA(n);
		if (get_u32(&handle, fhandle, 16)) {
			fprintf(stderr, "Unparsable filter ID \"%s\"\n", fhandle);
			return -1;
		}
		t->tcm_handle = handle;
	}
	return 0;
}
예제 #11
0
파일: aice_pipe.c 프로젝트: FelixVi/openocd
static int aice_pipe_read_debug_reg(uint32_t coreid, uint32_t addr, uint32_t *val)
{
	char line[AICE_PIPE_MAXLINE];
	char command[AICE_PIPE_MAXLINE];

	command[0] = AICE_READ_DEBUG_REG;
	set_u32(command + 1, addr);

	if (aice_pipe_write(command, 5) != 5)
		return ERROR_FAIL;

	if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
		return ERROR_FAIL;

	*val = get_u32(line);

	return ERROR_OK;
}
예제 #12
0
void ipoque_search_socrates(struct ipoque_detection_module_struct
							*ipoque_struct)
{
	struct ipoque_packet_struct *packet = &ipoque_struct->packet;
	struct ipoque_flow_struct *flow = ipoque_struct->flow;
//      struct ipoque_id_struct         *src=ipoque_struct->src;
//      struct ipoque_id_struct         *dst=ipoque_struct->dst;



	IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "search socrates.\n");
	if (packet->udp != NULL) {
		if (packet->payload_packet_len > 9 && packet->payload[0] == 0xfe
			&& packet->payload[packet->payload_packet_len - 1] == 0x05) {
			IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "found fe.\n");

			IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "len match.\n");
			if (memcmp(&packet->payload[2], "socrates", 8) == 0) {
				IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "found socrates udp.\n");
				ipoque_socrates_add_connection(ipoque_struct);
			}

		}
	} else if (packet->tcp != NULL) {
		if (packet->payload_packet_len > 13 && packet->payload[0] == 0xfe
			&& packet->payload[packet->payload_packet_len - 1] == 0x05) {
			IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "found fe.\n");
			if (packet->payload_packet_len == ntohl(get_u32(packet->payload, 2))) {
				IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "len match.\n");
				if (memcmp(&packet->payload[6], "socrates", 8) == 0) {
					IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "found socrates tcp.\n");
					ipoque_socrates_add_connection(ipoque_struct);
				}
			}
		}
	}




	IPQ_LOG(IPOQUE_PROTOCOL_SOCRATES, ipoque_struct, IPQ_LOG_DEBUG, "exclude socrates.\n");
	IPOQUE_ADD_PROTOCOL_TO_BITMASK(flow->excluded_protocol_bitmask, IPOQUE_PROTOCOL_SOCRATES);
}
예제 #13
0
파일: routerboot.c 프로젝트: whble/trunk
__init int
routerboot_find_magic(u8 *buf, unsigned int buflen, u32 *offset, bool hard)
{
	u32 magic_ref = hard ? RB_MAGIC_HARD : RB_MAGIC_SOFT;
	u32 magic;
	u32 cur = *offset;

	while (cur < buflen) {
		magic = get_u32(buf + cur);
		if (magic == magic_ref) {
			*offset = cur;
			return 0;
		}

		cur += 0x1000;
	}

	return -ENOENT;
}
예제 #14
0
파일: dhcp.c 프로젝트: kspviswa/Peafowl
u_int8_t check_dhcp(dpi_library_state_t* state, dpi_pkt_infos_t* pkt,
		            const unsigned char* app_data, u_int32_t data_length,
		            dpi_tracking_informations_t* t){
	if(data_length >= 244 && /** Minimum data_length. **/
	   /** Ports check. **/
	   ((pkt->srcport==port_dhcp_1 && pkt->dstport==port_dhcp_2) ||
	   (pkt->dstport==port_dhcp_1 && pkt->srcport==port_dhcp_2)) &&
	   /** Magic cookie. **/
	   get_u32(app_data, 236)==DPI_DHCP_MAGIC_COOKIE &&
	   /**
	    * First two bytes of DHCP message type.
	    * Are the same for any DHCP message type.
	    **/
	   get_u16(app_data, 240)==DPI_DHCP_TYPE){
		return DPI_PROTOCOL_MATCHES;
	}else{
		return DPI_PROTOCOL_NO_MATCHES;
	}
}
예제 #15
0
static bool
is_utf32 (const uint8_t *data, size_t n, uint32_t (*get_u32) (const uint8_t *))
{
  if (n < ENCODING_GUESS_MIN && n % 4 != 0)
    return false;

  while (n >= 4)
    {
      uint32_t uc = get_u32 (data);

      if (uc < 0x09 || uc > 0x10ffff)
        return false;

      data += 4;
      n -= 4;
    }

  return true;
}
예제 #16
0
/* Communicate with agent: send request and read reply */
static int
ssh_request_reply(int sock, struct sshbuf *request, struct sshbuf *reply)
{
	int r;
	size_t l, len;
	char buf[1024];

	/* Get the length of the message, and format it in the buffer. */
	len = sshbuf_len(request);
	put_u32(buf, len);

	/* Send the length and then the packet to the agent. */
	if (atomicio(vwrite, sock, buf, 4) != 4 ||
	    atomicio(vwrite, sock, (u_char *)sshbuf_ptr(request),
	    sshbuf_len(request)) != sshbuf_len(request))
		return SSH_ERR_AGENT_COMMUNICATION;
	/*
	 * Wait for response from the agent.  First read the length of the
	 * response packet.
	 */
	if (atomicio(read, sock, buf, 4) != 4)
	    return SSH_ERR_AGENT_COMMUNICATION;

	/* Extract the length, and check it for sanity. */
	len = get_u32(buf);
	if (len > MAX_AGENT_REPLY_LEN)
		return SSH_ERR_INVALID_FORMAT;

	/* Read the rest of the response in to the buffer. */
	sshbuf_reset(reply);
	while (len > 0) {
		l = len;
		if (l > sizeof(buf))
			l = sizeof(buf);
		if (atomicio(read, sock, buf, l) != l)
			return SSH_ERR_AGENT_COMMUNICATION;
		if ((r = sshbuf_put(reply, buf, l)) != 0)
			return r;
		len -= l;
	}
	return 0;
}
예제 #17
0
void bpa_dump(int level, struct frame *frm)
{
	uint8_t id, status, channel;
	uint16_t num, len;
	uint32_t time;

	id = get_u8(frm);
	num = get_u16(frm);
	len = BPA_U16(frm);

	status  = get_u8(frm);
	time    = get_u32(frm);
	channel = get_u8(frm);

	p_indent(level, frm);
	printf("BPA: id %d num %d len %u status 0x%02x time %d channel %d\n",
		id, num, len, status, time, channel);

	raw_dump(level, frm);
}
예제 #18
0
파일: puppy.c 프로젝트: silid/libpuppy
int do_cmd_turbo(int fd, char *state)
{
    int r;
    int turbo_on = atoi(state);

    if(0 == strcasecmp("ON", state))
    {
        turbo_on = 1;
    }

    r = send_cmd_turbo(fd, turbo_on);
    if(r < 0)
    {
        return -EPROTO;
    }

    r = get_tf_packet(fd, &reply);
    if(r < 0)
    {
        return -EPROTO;
    }

    switch (get_u32(&reply.cmd))
    {
        case SUCCESS:
            trace(1,
                  fprintf(stderr, "Turbo mode: %s\n",
                          turbo_on ? "ON" : "OFF"));
            return 0;
            break;

        case FAIL:
            fprintf(stderr, "ERROR: Device reports %s\n",
                    decode_error(&reply));
            break;

        default:
            fprintf(stderr, "ERROR: Unhandled packet\n");
    }
    return -EPROTO;
}
예제 #19
0
파일: sauce.c 프로젝트: bcopeland/ansiconv
int get_sauce(FILE *fp, sauce_t *out) 
{
    long cur_pos;

    cur_pos = ftell(fp);  
    if (fseek(fp, -128, SEEK_END) == -1)
        return -1;

    /* 
     * can't count on Sauce structure to be char aligned, 
     * so this bit reads it piecemeal.  Hate to add all these 
     * numbers without #defines, but they're in sauce.h if it 
     * really is confusing.
     */ 
    fread(out->id, 1, 5, fp);
    fread(out->version, 1, 2, fp);
    fread(out->title, 1, 35, fp);
    fread(out->author, 1, 20, fp);
    fread(out->group, 1, 20, fp);
    fread(out->date, 1, 8, fp);

    get_u32(&out->file_size, fp);

    fread(&out->data_type, 1, 1, fp);
    fread(&out->file_type, 1, 1, fp);

    get_u16(&out->t_info1, fp);
    get_u16(&out->t_info2, fp);
    get_u16(&out->t_info3, fp);
    get_u16(&out->t_info4, fp);

    fread(&out->comments, 1, 1, fp);
    fread(&out->flags, 1, 1, fp);

    fseek(fp, cur_pos, SEEK_SET);

    if (strncmp(out->id, "SAUCE", 5) == 0) 
        return 0;

    return -1;
}
예제 #20
0
void
mm_request_receive(int sock, Buffer *m)
{
	u_char buf[4];
	u_int msg_len;

	debug3("%s entering", __func__);

	if (atomicio(read, sock, buf, sizeof(buf)) != sizeof(buf)) {
		if (errno == EPIPE)
			cleanup_exit(255);
		fatal("%s: read: %s", __func__, strerror(errno));
	}
	msg_len = get_u32(buf);
	if (msg_len > 256 * 1024)
		fatal("%s: read: bad msg_len %d", __func__, msg_len);
	buffer_clear(m);
	buffer_append_space(m, msg_len);
	if (atomicio(read, sock, buffer_ptr(m), msg_len) != msg_len)
		fatal("%s: read: %s", __func__, strerror(errno));
}
예제 #21
0
파일: aice_pipe.c 프로젝트: FelixVi/openocd
static int aice_pipe_read_tlb(uint32_t coreid, uint32_t virtual_address,
		uint32_t *physical_address)
{
	char line[AICE_PIPE_MAXLINE];
	char command[AICE_PIPE_MAXLINE];

	command[0] = AICE_READ_TLB;
	set_u32(command + 1, virtual_address);

	if (aice_pipe_write(command, 5) != 5)
		return ERROR_FAIL;

	if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
		return ERROR_FAIL;

	if (line[0] == AICE_OK) {
		*physical_address = get_u32(line + 1);
		return ERROR_OK;
	} else
		return ERROR_FAIL;
}
예제 #22
0
int packet_fxp_open(Buffer *buff, Buffer *preped_buff) {
    u_int msg_len;
    u_int xmsg_len;
    
    // File names
    u_int file_len, pflags;
    u_char *filename;
    
    // Copy first part of packet over to prepared buffer
    msg_len = get_u32(buffer_ptr(buff));
    xmsg_len = msg_len;
    
    buffer_append(preped_buff, buffer_ptr(buff), 9);
    buffer_consume(buff, 9);
    xmsg_len -= 5;
    
    // Rewrite path
    filename = buffer_get_string(buff, &file_len);
    filename = unchroot_filename(filename, (u_char*) user_homedir);
    buffer_put_cstring(preped_buff, (char*) filename);
    xmsg_len -= (file_len + 4);
    msg_len += (strlen((char*) filename) - file_len);
    
    // pflags
    pflags = buffer_get_int(buff);
    buffer_put_int(preped_buff, pflags);
    xmsg_len -= 4;
    
    // Copy attributes through, cleaning extensions where required
    parse_attrs(buff, preped_buff, &msg_len, &xmsg_len);
    
    // Copy any remaining packet data over
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len);
    buffer_consume(buff, xmsg_len);
    
    // Rewrite message length
    put_u32(buffer_end(preped_buff)-msg_len-4, msg_len);
    
    return 1;
}
예제 #23
0
파일: tree.c 프로젝트: justinzane/navit
int tree_search_next(struct tree_search *ts, unsigned char **p, int dir)
{
	struct tree_search_node *tsn=&ts->nodes[ts->curr_node];

	if (! *p) 
		*p=tsn->p;
	dbg(1,"next *p=%p dir=%d\n", *p, dir);
	dbg(1,"low1=0x%x high1=0x%x\n", tsn->low, tsn->high);
	if (dir <= 0) {
		dbg(1,"down 0x%x\n", tsn->low);
		if (tsn->low != 0xffffffff) {
			tsn=tree_search_enter(ts, tsn->low);
			*p=tsn->p;
			tsn->high=get_u32(p);
			ts->last_node=ts->curr_node;
			dbg(1,"saving last2 %d 0x%x\n", ts->curr_node, tsn->last-ts->f->begin);
			dbg(1,"high2=0x%x\n", tsn->high);
			return 0;
		}
		return -1;
	}
	tsn->low=tsn->high;
	tsn->last=*p;
	tsn->high=get_u32_unal(p);
	dbg(1,"saving last3 %d %p\n", ts->curr_node, tsn->last);
	if (*p < tsn->end)
		return (tsn->low == 0xffffffff ? 1 : 0);
	dbg(1,"end reached high=0x%x\n",tsn->high);
	if (tsn->low != 0xffffffff) {
		dbg(1,"low 0x%x\n", tsn->low);
		tsn=tree_search_enter(ts, tsn->low);
		*p=tsn->p;
		tsn->high=get_u32_unal(p);
		ts->last_node=ts->curr_node;
		dbg(1,"saving last4 %d 0x%x\n", ts->curr_node, tsn->last-ts->f->begin);
		dbg(1,"high4=0x%x\n", tsn->high);
		return 0;
	}
	return -1;
}
예제 #24
0
파일: parse_tlv.cpp 프로젝트: LXiong/ccn
inline
static char *
get_address_tlv_value(char *msg_ptr, struct tlv_tuple_local *tuple)
{
  tuple->value = 0;
  tuple->multi_value = NULL;
  tuple->extended_value = NULL;

  switch (tuple->length)
    {
    case sizeof(olsr_u8_t):
      {
    olsr_u8_t v;
    msg_ptr = get_u8(msg_ptr, &v);
    tuple->value = v;
      }
      break;
    case sizeof(olsr_u16_t):
      {
    olsr_u16_t v;
    msg_ptr = get_u16(msg_ptr, &v);
    tuple->value = v;
      }
      break;
    case sizeof(olsr_u32_t):
      {
    olsr_u32_t v;
    msg_ptr = get_u32(msg_ptr, &v);
    tuple->value = v;
      }
      break;

    default:
      tuple->extended_value = (olsr_u8_t *)olsr_malloc(tuple->length,
                          __FUNCTION__);
      memcpy(tuple->extended_value, msg_ptr, tuple->length);
      msg_ptr += tuple->length;
    }
  return msg_ptr;
}
예제 #25
0
int packet_fxp_symlink(Buffer *buff, Buffer *preped_buff) {
    u_int msg_len;
    u_int xmsg_len;
    
    // File names
    u_int file_len;
    u_char *filename;
    
    // Copy first part of packet over to prepared buffer
    msg_len = get_u32(buffer_ptr(buff));
    xmsg_len = msg_len;
    
    buffer_append(preped_buff, buffer_ptr(buff), 9);
    buffer_consume(buff, 9);
    xmsg_len -= 5;
    
    // Rewrite link path
    filename = buffer_get_string(buff, &file_len);
    filename = unchroot_filename(filename, (u_char*) user_homedir);
    buffer_put_cstring(preped_buff, (char*) filename);
    xmsg_len -= (file_len + 4);
    msg_len += (strlen((char*) filename) - file_len);
    
    // Rewrite target path
    filename = buffer_get_string(buff, &file_len);
    filename = unchroot_filename(filename, (u_char*) user_homedir);
    buffer_put_cstring(preped_buff, (char*) filename);
    xmsg_len -= (file_len + 4);
    msg_len += (strlen((char*) filename) - file_len);
    
    // Copy any remaining packet data over
    buffer_append(preped_buff, buffer_ptr(buff), xmsg_len);
    buffer_consume(buff, xmsg_len);
    
    // Rewrite message length
    put_u32(buffer_end(preped_buff)-msg_len-4, msg_len);
    
    return 1;
}
예제 #26
0
/*Search for BitTorrent commands*/
int
search_bittorrent (const unsigned char *payload, const u16 plen)
{
    if (plen > 20)
    {
	/* test for match 0x13+"BitTorrent protocol" */
	if (*payload == 0x13)
	{
		if (memcmp(payload+1, "BitTorrent protocol", 19) == 0) return (IPP2P_BIT * 100);
	}

	/* get tracker commandos, all starts with GET /
	* then it can follow: scrape| announce
	* and then ?hash_info=
	*/
	if (memcmp(payload,"GET /",5) == 0)
	{
		/* message scrape */
		if ( memcmp(payload+5,"scrape?info_hash=",17)==0 ) return (IPP2P_BIT * 100 + 1);
		/* message announce */
		if ( memcmp(payload+5,"announce",8)==0 ) return (IPP2P_BIT * 100 + 2);
		if ( memcmp(payload+5,"?info_hash=",11)==0 ) return (IPP2P_BIT * 100 + 3);
		if ( memcmp(payload+5,"data?fid=",9)==0 ) return (IPP2P_BIT * 100 + 5);
	}
    }
    else
    {
    	/* bitcomet encryptes the first packet, so we have to detect another
    	 * one later in the flow */
    	 /* first try failed, too many missdetections */
    	//if ( size == 5 && get_u32(t,0) == __constant_htonl(1) && t[4] < 3) return (IPP2P_BIT * 100 + 3);

    	/* second try: block request packets */
    	if ( plen == 17 && get_u32(payload,0) == __constant_htonl(0x0d) && *(payload+4) == 0x06 && get_u32(payload,13) == __constant_htonl(0x4000) ) return (IPP2P_BIT * 100 + 4);
    }

    return 0;
}
예제 #27
0
static int labx_audio_meters_of_probe(struct of_device *ofdev, const struct of_device_id *match)
{
  struct resource r_mem_struct;
  struct resource *addressRange = &r_mem_struct;
  struct platform_device *pdev = to_platform_device(&ofdev->dev);
  u32 numChannels;
  int ret;
  u32 has_serializer;
  
  /* Obtain the resources for this instance; use the device tree node name */
  const char *name = ofdev->node->name;
  ret = of_address_to_resource(ofdev->node, 0, addressRange);
  if (ret) {
    dev_warn(&ofdev->dev, "Invalid address\n");
    return(ret);
  }

  /* Look up the number of channels in the device tree */
  numChannels = (1 << get_u32(ofdev, "xlnx,channel-addr-width"));

  /* Dispatch to the generic function */
  return(labx_audio_meters_probe(name, pdev, addressRange, numChannels));
}
예제 #28
0
파일: aice_pipe.c 프로젝트: FelixVi/openocd
static int aice_pipe_idcode(uint32_t *idcode, uint8_t *num_of_idcode)
{
	char line[AICE_PIPE_MAXLINE];
	char command[AICE_PIPE_MAXLINE];

	command[0] = AICE_IDCODE;

	if (aice_pipe_write(command, 1) != 1)
		return ERROR_FAIL;

	if (aice_pipe_read(line, AICE_PIPE_MAXLINE) < 0)
		return ERROR_FAIL;

	*num_of_idcode = line[0];

	if ((*num_of_idcode == 0) || (*num_of_idcode >= 16))
		return ERROR_FAIL;

	for (int i = 0 ; i < *num_of_idcode ; i++)
		idcode[i] = get_u32(line + i * 4 + 1);

	return ERROR_OK;
}
예제 #29
0
static uint_8 const *GetInt( uint_8 const *p, uint_32 *ret, int size )
/********************************************************************/
{
    switch( size ) {
    case 0:
        *ret = 0;
        break;
    case 1:
        *ret = *p;
        break;
    case 2:
        *ret = get_u16( (uint_16 *)p );
        break;
    case 4:
        *ret = get_u32( (uint_32 *)p );
        break;
    default:
        *ret = 0xffffffff;
        break;
    }
    p += size;
    return( p );
}
예제 #30
0
파일: puppy.c 프로젝트: nazgul77/libgphoto2
static int
get_info_func (CameraFilesystem *fs, const char *folder, const char *filename,
	       CameraFileInfo *info, void *data, GPContext *context)
{
	Camera *camera = data;
	int r;
	struct tf_packet reply;
	char *xfolder = strdup (folder);

	backslash (xfolder);

	r = send_cmd_hdd_dir(camera, xfolder, context);
	free (xfolder);
	if(r < GP_OK)
		return r;

	while(0 < get_tf_packet(camera, &reply, context)) {
		switch (get_u32(&reply.cmd)) {
		case DATA_HDD_DIR:
			decode_and_get_info(camera, folder, &reply, filename, info, context);
			send_success(camera,context);
			break;
		case DATA_HDD_DIR_END:
			return GP_OK;
			break;
		case FAIL:
			gp_log (GP_LOG_ERROR, "topfield", "ERROR: Device reports %s\n",
				decode_error(&reply));
			return GP_ERROR_IO;
			break;
		default:
			gp_log (GP_LOG_ERROR, "topfield", "ERROR: Unhandled packet\n");
			return GP_ERROR_IO;
		}
	}
	return GP_OK;
}