示例#1
0
文件: hex.c 项目: S010/misc
static void
hex(const char *s)
{
	unsigned long long i = 0;

	switch (s[0]) {
	case 'b':
	case 'B':
		i = read_bin(s + 1);
		break;
	case 'x':
	case 'X':
		i = read_hex(s + 1);
		break;
	case '0':
		if (s[1] == '\0')
			i = read_dec(s);
		else if (s[1] == 'x' || s[1] == 'X')
			i = read_hex(s + 2);
		else
			i = read_oct(s + 1);
		break;
	default:
		if (isdigit(*s))
			i = read_dec(s);
		else
			usage();
		break;
	}
	print_bin(i);
	print_chr(i);
	print_dec(i);
	print_hex(i);
	print_oct(i);
}
示例#2
0
int id2symbol(const char * id, Symbol ** res) {
    Symbol * sym = NULL;
    Context * ctx = NULL;
    ULONG64 module = 0;
    ULONG index = 0;
    unsigned frame = 0;
    const Symbol * base = NULL;
    const TypeInfo * info = NULL;
    size_t length = 0;
    const char * p;

    if (id != NULL && id[0] == '@' && id[1] == 'P') {
        p = id + 2;
        length = (size_t)read_hex(&p);
        if (*p == '.') p++;
        if (id2symbol(p, (Symbol **)&base)) return -1;
        ctx = base->ctx;
    }
    else if (id != NULL && id[0] == '@' && id[1] == 'S') {
        unsigned idx = 0;
        p = id + 2;
        module = (ULONG64)read_hex(&p);
        if (*p == '.') p++;
        index = (ULONG)read_hex(&p);
        if (*p == '.') p++;
        frame = (unsigned)read_hex(&p);
        if (*p == '.') p++;
        idx = (unsigned)read_hex(&p);
        if (idx) info = basic_type_info + (idx - 1);
        if (*p == '.') p++;
        ctx = id2ctx(p);
    }
    else {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    if (ctx == NULL) {
        errno = ERR_INV_CONTEXT;
        return -1;
    }
    sym = alloc_symbol();
    sym->ctx = ctx;
    sym->module = module;
    sym->index = index;
    sym->frame = frame;
    sym->base = base;
    sym->info = info;
    sym->length = length;
    if (sym->base || sym->info) {
        sym->sym_class = SYM_CLASS_TYPE;
    }
    else {
        DWORD dword = 0;
        if (get_type_info(sym, TI_GET_SYMTAG, &dword) < 0) return -1;
        tag2symclass(sym, dword);
    }
    *res = sym;
    return 0;
}
示例#3
0
static int
usbdevfs_reapurb_init_from_text(ioctl_tree * node, const char *data)
{
    struct usbdevfs_urb *info = calloc(sizeof(struct usbdevfs_urb), 1);
    int offset, result;
    unsigned type, endpoint;
    result = sscanf(data, "%u %u %i %u %i %i %i %n", &type, &endpoint,
		    &info->status, &info->flags, &info->buffer_length,
		    &info->actual_length, &info->error_count, &offset);
    /* ambiguity of counting or not %n */
    if (result < 7) {
	DBG(DBG_IOCTL_TREE, "usbdevfs_reapurb_init_from_text: failed to parse record '%s'\n", data);
	free(info);
	return FALSE;
    }
    info->type = (unsigned char)type;
    info->endpoint = (unsigned char)endpoint;

    /* read buffer */
    info->buffer = calloc(info->buffer_length, 1);
    if (!read_hex(data + offset, info->buffer, info->buffer_length)) {
	DBG(DBG_IOCTL_TREE, "usbdevfs_reapurb_init_from_text: failed to parse buffer '%s'\n", data + offset);
	free(info->buffer);
	free(info);
	return FALSE;
    };

    node->data = info;
    return TRUE;
}
示例#4
0
static int
ioctl_varlenstruct_init_from_text(ioctl_tree * node, const char *data)
{
    size_t data_len = strlen(data) / 2;

    node->data = malloc(data_len);

    if (!read_hex(data, node->data, data_len)) {
	fprintf(stderr, "ioctl_varlenstruct_init_from_text: failed to parse '%s'\n", data);
	free(node->data);
	return FALSE;
    }

    /* verify that the text data size actually matches get_data_size() */
    size_t size = node->type->get_data_size(node->id, node->data);

    if (size != data_len) {
	fprintf(stderr, "ioctl_varlenstruct_init_from_text: ioctl %lX: expected data length %zu, but got %zu bytes from text data\n",
		node->id, size, data_len);
	free(node->data);
	return FALSE;
    }

    return TRUE;
}
示例#5
0
static void
xbsd_change_fstype(void)
{
    int i;

    i = xbsd_get_part_index(xbsd_dlabel.d_npartitions);
    xbsd_dlabel.d_partitions[i].p_fstype = read_hex(xbsd_fstypes);
}
void vcs_from_str(struct vcs_rel *rel, const char *text)
{
	char token[80];
	int plus=0;
	enum { begin, f_ver, f_svn, f_rev, f_git, f_srcv } ex = begin;

	while (sget_token(token, sizeof(token), &text) != EOF) {
		switch(ex) {
		case begin:
			if(!strcmp(token,"version:"))
				ex = f_ver;
			if(!strcmp(token,"SVN"))  ex = f_svn;
			if(!strcmp(token,"GIT-hash:"))  ex = f_git;
			if(!strcmp(token,"srcversion:"))  ex = f_srcv;
			break;
		case f_ver:
			if(!strcmp(token,"plus"))
				plus = 1;
				/* still waiting for version */
			else {
				vcs_ver_from_str(rel, token);
				ex = begin;
			}
			break;
		case f_svn:
			if(!strcmp(token,"Revision:"))  ex = f_rev;
			break;
		case f_rev:
			rel->svn_revision = atol(token) * 10;
			if( plus ) rel->svn_revision += 1;
			memset(rel->git_hash, 0, GIT_HASH_BYTE);
			return;
		case f_git:
			read_hex(rel->git_hash, token, GIT_HASH_BYTE, strlen(token));
			rel->svn_revision = 0;
			return;
		case f_srcv:
			memset(rel->git_hash, 0, SRCVERSION_PAD);
			read_hex(rel->git_hash + SRCVERSION_PAD, token, SRCVERSION_BYTE, strlen(token));
			rel->svn_revision = 0;
			return;
		}
	}
}
示例#7
0
文件: vendor.c 项目: dimkr/iw
static int handle_vendor(struct nl80211_state *state,
			 struct nl_msg *msg, int argc, char **argv,
			 enum id_input id)
{
	unsigned int oui;
	unsigned int subcmd;
	char buf[2048] = {};
	int res, count = 0;
	FILE *file = NULL;

	if (argc < 3)
		return 1;

	res = sscanf(argv[0], "0x%x", &oui);
	if (res != 1) {
		printf("Vendor command must start with 0x\n");
		return 2;
	}

	res = sscanf(argv[1], "0x%x", &subcmd);
	if (res != 1) {
		printf("Sub command must start with 0x\n");
		return 2;
	}

	if (!strcmp(argv[2], "-"))
		file = stdin;
	else
		file = fopen(argv[2], "r");

	NLA_PUT_U32(msg, NL80211_ATTR_VENDOR_ID, oui);
	NLA_PUT_U32(msg, NL80211_ATTR_VENDOR_SUBCMD, subcmd);

	if (file) {
		count = read_file(file, buf, sizeof(buf));
		fclose(file);
	} else
		count = read_hex(argc - 2, &argv[2], buf, sizeof(buf));

	if (count < 0)
		return -EINVAL;

	if (count > 0)
		NLA_PUT(msg, NL80211_ATTR_VENDOR_DATA, count, buf);

	return 0;

nla_put_failure:
	return -ENOBUFS;
}
示例#8
0
static int read_data(FILE *f, TDB_DATA *d, size_t size) {
	int c, low, high;
	int i;

	d->dptr = (unsigned char *)malloc(size);
	if (d->dptr == NULL) {
		return -1;
	}
	d->dsize = size;

	for (i=0; i<size; i++) {
		c = getc(f);
		if (c == EOF) {
			fprintf(stderr, "Unexpected EOF in data\n");
			return 1;
		} else if (c == '"') {
			return 0;
		} else if (c == '\\') {
			high = read_hex();
			if (high < 0) {
				return -1;
			}
			high = high << 4;
			assert(high == (high & 0xf0));
			low = read_hex();
			if (low < 0) {
				return -1;
			}
			assert(low == (low & 0x0f));
			d->dptr[i] = (low|high);
		} else {
			d->dptr[i] = c;
		}
	}
	return 0;
}
示例#9
0
static int
ioctl_simplestruct_init_from_text(ioctl_tree * node, const char *data)
{
    /* node->id is initialized at this point, but does not necessarily have the
     * correct length for data; this happens for variable length ioctls such as
     * EVIOCGBIT */
    size_t data_len = strlen(data) / 2;
    node->data = malloc(data_len);

    if (NSIZE(node) != data_len) {
	DBG(DBG_IOCTL_TREE, "ioctl_simplestruct_init_from_text: adjusting ioctl ID %lX (size %lu) to actual data length %zu\n",
	    node->id, NSIZE(node), data_len);
	node->id = _IOC(_IOC_DIR(node->id), _IOC_TYPE(node->id), _IOC_NR(node->id), data_len);
    }

    if (!read_hex(data, node->data, NSIZE(node))) {
	DBG(DBG_IOCTL_TREE, "ioctl_simplestruct_init_from_text: failed to parse '%s'\n", data);
	free(node->data);
	return FALSE;
    }
    return TRUE;
}
示例#10
0
bfd_boolean
generate_build_id (bfd *abfd,
		   const char *style,
		   checksum_fn checksum_contents,
		   unsigned char *id_bits,
		   int size ATTRIBUTE_UNUSED)
{
  if (streq (style, "md5"))
    {
      struct md5_ctx ctx;

      md5_init_ctx (&ctx);
      if (!(*checksum_contents) (abfd, (sum_fn) &md5_process_bytes, &ctx))
	return FALSE;
      md5_finish_ctx (&ctx, id_bits);
    }
  else if (streq (style, "sha1"))
    {
      struct sha1_ctx ctx;

      sha1_init_ctx (&ctx);
      if (!(*checksum_contents) (abfd, (sum_fn) &sha1_process_bytes, &ctx))
	return FALSE;
      sha1_finish_ctx (&ctx, id_bits);
    }
  else if (streq (style, "uuid"))
    {
#ifndef __MINGW32__
      int n;
      int fd = open ("/dev/urandom", O_RDONLY);

      if (fd < 0)
	return FALSE;
      n = read (fd, id_bits, size);
      close (fd);
      if (n < size)
	return FALSE;
#else /* __MINGW32__ */
      typedef RPC_STATUS (RPC_ENTRY * UuidCreateFn) (UUID *);
      UUID          uuid;
      UuidCreateFn  uuid_create = 0;
      HMODULE       rpc_library = LoadLibrary ("rpcrt4.dll");

      if (!rpc_library)
	return FALSE;
      uuid_create = (UuidCreateFn) (void (WINAPI *)(void)) GetProcAddress (rpc_library, "UuidCreate");
      if (!uuid_create)
	{
	  FreeLibrary (rpc_library);
	  return FALSE;
	}

      if (uuid_create (&uuid) != RPC_S_OK)
	{
	  FreeLibrary (rpc_library);
	  return FALSE;
	}
      FreeLibrary (rpc_library);
      memcpy (id_bits, &uuid,
	      (size_t) size < sizeof (UUID) ? (size_t) size : sizeof (UUID));
#endif /* __MINGW32__ */
    }
  else if (strneq (style, "0x", 2))
    {
      /* ID is in string form (hex).  Convert to bits.  */
      const char *id = style + 2;
      size_t n = 0;

      do
	{
	  if (ISXDIGIT (id[0]) && ISXDIGIT (id[1]))
	    {
	      id_bits[n] = read_hex (*id++) << 4;
	      id_bits[n++] |= read_hex (*id++);
	    }
	  else if (*id == '-' || *id == ':')
	    ++id;
	  else
	    abort ();		/* Should have been validated earlier.  */
	}
      while (*id != '\0');
    }
  else
    abort ();			/* Should have been validated earlier.  */

  return TRUE;
}
示例#11
0
/*
 * We switch the user's privilege to read ~/.gfarm_shared_key.
 *
 * NOTE: reading this file with root privilege may not work,
 *	if home directory is NFS mounted and root access for
 *	the home directory partition is not permitted.
 *
 * Do not leave the user privilege switched here, even in the switch_to case,
 * because it is necessary to switch back to the original user privilege when
 * gfarm_auth_sharedsecret fails.
 */
gfarm_error_t
gfarm_auth_shared_key_get(unsigned int *expirep, char *shared_key,
	char *home, struct passwd *pwd, int create, int period)
{
	gfarm_error_t e;
	FILE *fp;
	static char keyfile_basename[] = "/" GFARM_AUTH_SHARED_KEY_BASENAME;
	char *keyfilename;
	unsigned int expire;

	static pthread_mutex_t privilege_mutex = PTHREAD_MUTEX_INITIALIZER;
	uid_t o_uid;
	gid_t o_gid;

#ifdef __GNUC__ /* workaround gcc warning: might be used uninitialized */
	o_uid = o_gid = 0;
#endif
	GFARM_MALLOC_ARRAY(keyfilename, 
		strlen(home) + sizeof(keyfile_basename));
	if (keyfilename == NULL)
		return (GFARM_ERR_NO_MEMORY);
	strcpy(keyfilename, home);
	strcat(keyfilename, keyfile_basename);

	if (pwd != NULL) {
		pthread_mutex_lock(&privilege_mutex);
		o_gid = getegid();
		o_uid = geteuid();
		seteuid(0); /* recover root privilege */
		initgroups(pwd->pw_name, pwd->pw_gid);
		setegid(pwd->pw_gid);
		seteuid(pwd->pw_uid);
	}

	if ((fp = fopen(keyfilename, "r+")) != NULL) {
		if (skip_space(fp) || read_hex(fp, &expire, sizeof(expire))) {
			fclose(fp);
			free(keyfilename);
			e = GFARM_ERRMSG_SHAREDSECRET_INVALID_EXPIRE_FIELD;
			goto finish;
		}
		expire = ntohl(expire);
		if (skip_space(fp) ||
		    read_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN)) {
			fclose(fp);
			free(keyfilename);
			e = GFARM_ERRMSG_SHAREDSECRET_INVALID_KEY_FIELD;
			goto finish;
		}
	}
	if (fp == NULL) {
		if (create == GFARM_AUTH_SHARED_KEY_GET) {
			free(keyfilename);
			e = GFARM_ERRMSG_SHAREDSECRET_KEY_FILE_NOT_EXIST;
			goto finish;
		}
		fp = fopen(keyfilename, "w+");
		if (fp == NULL) {
			e = gfarm_errno_to_error(errno);
			free(keyfilename);
			goto finish;
		}
		if (chmod(keyfilename, 0600) == -1) {
			e = gfarm_errno_to_error(errno);
			fclose(fp);
			free(keyfilename);
			goto finish;
		}
		expire = 0; /* force to regenerate key */
	}
	if (create == GFARM_AUTH_SHARED_KEY_CREATE_FORCE ||
	    time(NULL) >= expire) {
		if (create == GFARM_AUTH_SHARED_KEY_GET) {
			fclose(fp);
			free(keyfilename);
			e = GFARM_ERR_EXPIRED;
			goto finish;
		}
		if (fseek(fp, 0L, SEEK_SET) == -1) {
			e = gfarm_errno_to_error(errno);
			fclose(fp);
			free(keyfilename);
			goto finish;
		}
		gfarm_auth_random(shared_key, GFARM_AUTH_SHARED_KEY_LEN);
		if (period <= 0)
			period = GFARM_AUTH_EXPIRE_DEFAULT;
		expire = time(NULL) + period;
		expire = htonl(expire);
		write_hex(fp, &expire, sizeof(expire));
		expire = ntohl(expire);
		fputc(' ', fp);
		write_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN);
		fputc('\n', fp);
	}
	fclose(fp);
	free(keyfilename);
	*expirep = expire;
	e = GFARM_ERR_NO_ERROR;
finish:
	if (pwd != NULL) {
		seteuid(0); /* recover root privilege */
		setgroups(1, &o_gid); /* abandon group privileges */
		setegid(o_gid);
		seteuid(o_uid); /* suppress root privilege, if possible */
		pthread_mutex_unlock(&privilege_mutex);
	}
	return (e);
}
示例#12
0
int main(int argc, char *argv[])
{
struct _memory memory;
char *filename=NULL;
char *uart="/dev/ttyUSB0";
int prog_type=PROG_UNDEF;
int command=COMMAND_UNDEF;
int param1=0,param2=0;
int i;

  printf("\nnaken_prog - by Michael Kohn\n");
  printf("    Web: http://www.mikekohn.net/\n");
  printf("  Email: [email protected]\n\n");
  printf("Version: "VERSION"\n\n");

  if (argc<2)
  {
    printf("Usage: naken_util [options]\n");
    printf("  CPU options:\n");
    printf("   -lpc\n");
    printf("  Command:\n");
    printf("   -info\n");
    printf("   -write <outfile>\n");
    printf("   -read <address> <count> <infile>\n");
    printf("   -execute <address>\n");
    printf("\n");
    exit(0);
  }

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

  for (i=1; i<argc; i++)
  {
    if (strcmp(argv[i], "-lpc")==0)
    {
      prog_type=PROG_LPC;
    }
      else
    if (strcmp(argv[i], "-info")==0)
    {
      command=COMMAND_INFO;
    }
      else
    if (strcmp(argv[i], "-read")==0)
    {
      command=COMMAND_READ;
      if (i+2>=argc)
      {
        printf("Error: -read command takes 2 arguments\n");
        exit(1);
      }
      param1=atoi(argv[++i]);
      param2=atoi(argv[++i]);
    }
      else
    if (strcmp(argv[i], "-write")==0)
    {
      command=COMMAND_WRITE;
    }
      else
    if (strcmp(argv[i], "-run")==0)
    {
      command=COMMAND_RUN;
      param1=atoi(argv[++i]);
    }
      else
    {
      filename=argv[i];
    }
  }

  if (prog_type==PROG_UNDEF)
  {
    printf("Error: No chip type selected.\n");
    exit(0);
  }

  if (command==COMMAND_INFO)
  {
    if (prog_type==PROG_LPC)
    {
      lpc_info(uart);
    }
  }
    else
  if (command==COMMAND_READ)
  {
    if (filename==NULL)
    {
      printf("No output filename.  Exiting...\n");
      exit(1);
    }

    memory_init(&memory, 0xffffffff, 1);
    lpc_memory_read(uart, &memory, param1, param2);
    // FIXME - make filename selectable
    FILE *out=fopen(filename, "wb");
    write_hex(&memory, out);
    fclose(out);
    memory_free(&memory);
  }
    else
  if (command==COMMAND_WRITE)
  {
    unsigned char cpu_type;

    if (filename==NULL)
    {
      printf("No hexfile loaded.  Exiting...\n");
      exit(1);
    }

    memory_init(&memory, 0xffffffff, 1);

    if (read_elf(filename, &memory, &cpu_type, NULL)>=0)
    {
      printf("Loaded ELF %s from 0x%04x to 0x%04x\n", filename, memory.low_address, memory.high_address);
    }
      else
    if (read_hex(filename, &memory)>=0)
    {
      printf("Loaded hexfile %s from 0x%04x to 0x%04x\n", filename, memory.low_address, memory.high_address);
    }
      else
    {
      printf("Could not load hexfile\n");
      memory_free(&memory);
      exit(1);
    }

    lpc_memory_write(uart, &memory);
    memory_free(&memory);
  }
    else
  if (command==COMMAND_RUN)
  {
    if (prog_type==PROG_LPC)
    {
      lpc_run(uart, param1);
    }
  }

  return 0;
}
示例#13
0
char *
gfarm_auth_shared_key_get(unsigned int *expirep, char *shared_key,
			  char *home, int create, int period)
{
	FILE *fp;
	static char keyfile_basename[] = "/" GFARM_AUTH_SHARED_KEY_BASENAME;
	char *keyfilename;
	unsigned int expire;

	keyfilename = malloc(strlen(home) + sizeof(keyfile_basename));
	if (keyfilename == NULL)
		return (GFARM_ERR_NO_MEMORY);
	strcpy(keyfilename, home);
	strcat(keyfilename, keyfile_basename);
	if ((fp = fopen(keyfilename, "r+")) != NULL) {
		if (skip_space(fp) || read_hex(fp, &expire, sizeof(expire))) {
			fclose(fp);
			free(keyfilename);
			return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
				": invalid expire field");
		}
		expire = ntohl(expire);
		if (skip_space(fp) ||
		    read_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN)) {
			fclose(fp);
			free(keyfilename);
			return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
				": invalid key field");
		}
	}
	if (fp == NULL) {
		if (create == GFARM_AUTH_SHARED_KEY_GET) {
			free(keyfilename);
			return ("~/" GFARM_AUTH_SHARED_KEY_BASENAME
				": not exist");
		}
		fp = fopen(keyfilename, "w+");
		if (fp == NULL) {
			free(keyfilename);
			return (gfarm_errno_to_error(errno));
		}
		if (chmod(keyfilename, 0600) == -1) {
			fclose(fp);
			free(keyfilename);
			return (gfarm_errno_to_error(errno));
		}
		expire = 0; /* force to regenerate key */
	}
	if (create == GFARM_AUTH_SHARED_KEY_CREATE_FORCE ||
	    time(NULL) >= expire) {
		if (create == GFARM_AUTH_SHARED_KEY_GET) {
			fclose(fp);
			free(keyfilename);
			return (GFARM_ERR_EXPIRED);
		}
		if (fseek(fp, 0L, SEEK_SET) == -1) {
			fclose(fp);
			free(keyfilename);
			return (gfarm_errno_to_error(errno));
		}
		gfarm_auth_random(shared_key, GFARM_AUTH_SHARED_KEY_LEN);
		if (period <= 0)
			period = GFARM_AUTH_EXPIRE_DEFAULT;
		expire = time(NULL) + period;
		expire = htonl(expire);
		write_hex(fp, &expire, sizeof(expire));
		expire = ntohl(expire);
		fputc(' ', fp);
		write_hex(fp, shared_key, GFARM_AUTH_SHARED_KEY_LEN);
		fputc('\n', fp);
	}
	fclose(fp);
	free(keyfilename);
	*expirep = expire;
	return (NULL);
}
示例#14
0
/*
 * Given the global variables buffer and buffer_len, append at their end
 * the commands that with type action and action param action_param.
 * @param action the id of the action.
 * @param action_param the parameter of the action
 * @todo code is very dirty. Needs to be refactored. 
 */
int
append_action(int action, const char *action_param) {
  struct ofp_action_output *act_out;
  struct ofp_action_vlan_vid *act_vid;
  struct ofp_action_vlan_pcp *act_pcp;
  struct ofp_action_header *act;
  struct ofp_action_dl_addr *act_dl;
  struct ofp_action_nw_addr *act_nw;
  struct ofp_action_tp_port *act_port;
  switch(action) {
  case OFPAT_OUTPUT:
    fprintf(stderr, "output packet to port %s\n", action_param);
    command_len += sizeof(struct ofp_action_output);

    command = realloc(command, command_len);
    act_out = (struct ofp_action_output *)
      (command + (command_len - sizeof(struct ofp_action_output)));
    act_out->type = htons(action);
    act_out->len = htons(8);
    act_out->max_len = htons(0);
    act_out->port = htons((uint16_t)strtol(action_param, NULL, 16));
    break;
  case OFPAT_SET_VLAN_VID:
    if( (strtol(action_param, NULL, 16) < 0) || (strtol(action_param, NULL, 16) >= 0xFFF)) {
      printf("invalid vlan id\n");
      return -1;
    }
    fprintf(stderr, "change vlan to %ld\n", strtol(action_param, NULL, 16));
    command_len += sizeof(struct ofp_action_vlan_vid);
    command = realloc(command, command_len);
    act_vid = (struct ofp_action_vlan_vid *)
      (command+(command_len-sizeof(struct ofp_action_vlan_vid)));
    act_vid->type = htons(action);
    act_vid->len = htons(8);
    act_vid->vlan_vid = htons((uint16_t)strtol(action_param, NULL, 16));
    break;
  case OFPAT_SET_VLAN_PCP:
    if( (strtol(action_param, NULL, 16) < 0) || (strtol(action_param, NULL, 16) > 7)) {
      printf("invalid vlan pcp\n");
      return -1;
    }
    printf("change vlan pcp %ld\n", strtol(action_param, NULL, 16));
    command_len += sizeof(struct ofp_action_vlan_pcp);
    command = realloc(command, command_len);
    act_pcp = (struct ofp_action_vlan_pcp *)
      (command + (command_len - sizeof(struct ofp_action_vlan_pcp)));
    act_pcp->type = htons(action);
    act_pcp->len = htons(8);
    act_pcp->vlan_pcp = (uint8_t)strtol(action_param, NULL, 16); 
    break;
  case OFPAT_STRIP_VLAN:
    printf("strip vlan header\n");
    command_len += sizeof(struct ofp_action_header);
    command = realloc(command, command_len);
    act = (struct ofp_action_header *)
      (command + (command_len - sizeof(struct ofp_action_header)));
    act->type = htons(action);
    act->len = htons(8);
    break;
  case OFPAT_SET_DL_SRC:
  case OFPAT_SET_DL_DST:
    printf("Change ethernet address to %s\n", action_param);
    if((strlen(action_param) != 12) || (is_hex(action_param, 12) == 0)) {
      printf("invalid mac address\n");
      return -1;
    }
    command_len += sizeof(struct ofp_action_dl_addr);
    command = realloc(command, command_len);
    act_dl = (struct ofp_action_dl_addr *)
      (command + (command_len - sizeof(struct ofp_action_dl_addr)));
    act_dl->type = htons(action);
    act_dl->len = htons(16);
    int i;
    for(i = 0 ; i < 6; i++) {
      act_dl->dl_addr[i] = read_hex(action_param);
      action_param += 2;
    }
    break;
  case OFPAT_SET_NW_SRC:
  case OFPAT_SET_NW_DST:
    printf("Change ip address to %s\n", action_param);
    if((strlen(action_param) != 8) || (is_hex(action_param, 8) == 0)) {
      printf("invalid ip address\n");
      return -1;
    }
    command_len += sizeof(struct ofp_action_nw_addr);
    command = realloc(command, command_len);
    act_nw = (struct ofp_action_nw_addr *)
      (command + (command_len - sizeof(struct ofp_action_nw_addr)));
    act_nw->type = htons(action);
    act_nw->len = htons(8);
    act_nw->nw_addr = htonl(strtol(action_param, NULL, 16));
    break;
  case OFPAT_SET_TP_SRC:
  case OFPAT_SET_TP_DST:
    printf("change port to %ld\n", strtol(action_param, NULL, 16));
    command_len += sizeof(struct ofp_action_tp_port);
    command = realloc(command, command_len);
    act_port = (struct ofp_action_tp_port *)
      (command + (command_len - sizeof(struct ofp_action_tp_port)));
    act_port->type = htons(action);
    act_port->len = htons(8);
    act_port->tp_port = htons((uint16_t)strtol(action_param, NULL, 16));
    break;
  }    
  return 0;
}
示例#15
0
文件: tlexer.c 项目: fy0/tinyre
_INLINE static
int token_char_accept(tre_Lexer *lex, uint32_t code, bool use_back_ref) {
    if (code == '\\') {
        // 对转义字符做特殊处理
        if (lex->scur == lex->slen) {
            // 如果已经是最后一个字符,那么当作普通字符即可
            lex->token.extra.code = code;
            lex->token.value = TK_CHAR;
        } else {
            // 如果不是,读下一个字符
            code = char_lookahead(lex);
            if (is_spe_char(code)) {
                // 能确定为特殊匹配字符的话,读取结束
                lex->token.extra.code = code;
                lex->token.value = TK_CHAR_SPE;
                code = char_next(lex);
            } else {
                // 否则当做 hex/unicode 转义处理
                int num, len;
                bool is_ok = false;

                if (code == 'x') {
                    code = char_next(lex);
                    num = read_hex(lex, 2, &is_ok);
                    if (!is_ok) return ERR_LEXER_HEX_ESCAPE;
                    char_nextn(lex, 2);
                } else if (code == 'u') {
                    code = char_next(lex);
                    num = read_hex(lex, 4, &is_ok);
                    if (!is_ok) return ERR_LEXER_UNICODE_ESCAPE;
                    char_nextn(lex, 4);
                } else if (code == 'U') {
                    code = char_next(lex);
                    num = read_hex(lex, 8, &is_ok); // unicode 6.0 \U0000000A
                    if (!is_ok) return ERR_LEXER_UNICODE6_ESCAPE;
                    char_nextn(lex, 8);
                }

                if (is_ok) {
                    lex->token.value = TK_CHAR;
                    lex->token.extra.code = num;
                } else {
                    num = read_int(lex, 0, &len);
                    if (num != -1) {
                        // back reference or normal char
                        if (use_back_ref) {
                            if (num == 0) {
                                lex->token.value = TK_CHAR;
                                lex->token.extra.code = 0;
                            } else {
                                lex->token.value = TK_BACK_REF;
                                lex->token.extra.index = num;
                            }
                        } else {
                            lex->token.value = TK_CHAR;
                            lex->token.extra.code = num;
                        }
                        char_nextn(lex, len);
                    } else {
                        // 既不是转义,也不是前向引用,只是一个字符罢了
                        lex->token.value = TK_CHAR;
                        lex->token.extra.code = code;
                        char_next(lex);
                    }
                }
            }
        }
    } else {
        // 若非转义字符,那么一切都很简单
        lex->token.extra.code = code;
        lex->token.value = (code == '.') ? TK_CHAR_SPE : TK_CHAR;
    }
    return 0;
}
示例#16
0
int main(int argc, char *argv[])
{
	struct hexfile hf;
	FILE *tf;
	int pos, i;

	printf("hex2txt - convert an Intel hex/a43 file to TI txt format (max. %d bytes)\n", MAX_SIZE);
	
	if (argc != 3)
	{
		printf("usage: hex2txt <inputfile> <outputfile>\n");
		return 1;
	}

	if (init_hexfile(&hf, MAX_SIZE, NULL, argv[1])!=0)
	{
		printf("error opening hex file %s\n", argv[1]);
		return 1;
	}
 
	printf("reading hex file %s...\n", argv[1]);
	if (read_hex(&hf)!=0)
	{
		printf("error in hex file %s\n", argv[1]);
		destroy_hexfile(&hf);
		return 1;
	}

	tf = fopen(argv[2], "w");
	if (tf==NULL)
	{
		printf("error creating txt file %s\n", argv[2]);
		return 1;
	}

	printf("writing txt file %s...\n", argv[2]);

	pos = 0;
	do
	{
		while (pos<hf.memsize && hf.flag[pos]!=0)
			pos++;
		if (pos>=hf.memsize)
			break;
		fprintf(tf, "@%X", pos);
		i = 0;
		do
		{
			if (i%16==0)
				fprintf(tf, "\n");
			else
				fprintf(tf, " ");
			i++;
			fprintf(tf, "%02X", hf.mem[pos]);
			pos++;
		}
		while (pos<hf.memsize && hf.flag[pos]==0);
		fprintf(tf, "\n");
	}
	while (pos<hf.memsize);

	fprintf(tf, "q\n");

	fclose(tf);

	destroy_hexfile(&hf);

	printf("done.\n");

	return 0;
}