예제 #1
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_params(compile_t* c, printbuf_t* buf, ast_t* params)
{
  ast_t* param = ast_child(params);

  while(param != NULL)
  {
    AST_GET_CHILDREN(param, id, ptype);

    // Print the parameter.
    printbuf(buf, ", ");
    print_type_name(c, buf, ptype);

    // Smash trailing primes to underscores.
    const char* name = ast_name(id);
    size_t len = strlen(name) + 1;
    size_t buf_size = len;
    char* buffer = (char*)ponyint_pool_alloc_size(buf_size);
    memcpy(buffer, name, len);

    len--;

    while(buffer[--len] == '\'')
      buffer[len] = '_';

    printbuf(buf, " %s", buffer);

    param = ast_sibling(param);
    ponyint_pool_free_size(buf_size, buffer);
  }
}
예제 #2
0
파일: ast.c 프로젝트: awaidmann/ponyc
static void print_typeexpr(printbuf_t* buffer, ast_t* type, const char* sep,
  bool square)
{
  if(square)
    printbuf(buffer, "[");
  else
    printbuf(buffer, "(");

  ast_t* child = ast_child(type);

  while(child != NULL)
  {
    ast_t* next = ast_sibling(child);
    print_type(buffer, child);

    if(next != NULL)
      printbuf(buffer, "%s", sep);

    child = next;
  }

  if(square)
    printbuf(buffer, "]");
  else
    printbuf(buffer, ")");
}
예제 #3
0
/*
 * lanplus_encrypt_aes_cbc_128
 *
 * Encrypt with the AES CBC 128 algorithm
 *
 * param iv is the 16 byte initialization vector
 * param key is the 16 byte key used by the AES algorithm
 * param input is the data to be encrypted
 * param input_length is the number of bytes to be encrypted.  This MUST
 *       be a multiple of the block size, 16.
 * param output is the encrypted output
 * param bytes_written is the number of bytes written.  This param is set
 *       to 0 on failure, or if 0 bytes were input.
 */
void
lanplus_encrypt_aes_cbc_128(const uint8_t * iv,
							const uint8_t * key,
							const uint8_t * input,
							uint32_t          input_length,
							uint8_t       * output,
							uint32_t        * bytes_written)
{
	EVP_CIPHER_CTX ctx;
	EVP_CIPHER_CTX_init(&ctx);
	EVP_EncryptInit_ex(&ctx, EVP_aes_128_cbc(), NULL, key, iv);
	EVP_CIPHER_CTX_set_padding(&ctx, 0);
	

	*bytes_written = 0;

	if (input_length == 0)
		return;

	if (verbose >= 5)
	{
		printbuf(iv,  16, "encrypting with this IV");
		printbuf(key, 16, "encrypting with this key");
		printbuf(input, input_length, "encrypting this data");
	}


	/*
	 * The default implementation adds a whole block of padding if the input
	 * data is perfectly aligned.  We would like to keep that from happening.
	 * We have made a point to have our input perfectly padded.
	 */
	assert((input_length % IPMI_CRYPT_AES_CBC_128_BLOCK_SIZE) == 0);


	if(!EVP_EncryptUpdate(&ctx, output, (int *)bytes_written, input, input_length))
	{
		/* Error */
		*bytes_written = 0;
		return;
	}
	else
	{
		uint32_t tmplen;

		if(!EVP_EncryptFinal_ex(&ctx, output + *bytes_written, (int *)&tmplen))
		{
			*bytes_written = 0;
			return; /* Error */
		}
		else
		{
			/* Success */
			*bytes_written += tmplen;
			EVP_CIPHER_CTX_cleanup(&ctx);
		}
	}
}
예제 #4
0
파일: reach.c 프로젝트: Sendence/ponyc
static const char* make_mangled_name(reach_method_t* m)
{
  // Generate the mangled name.
  // cap_name[_Arg1_Arg2]_args_result
  printbuf_t* buf = printbuf_new();
  printbuf(buf, "%s_", m->name);

  for(size_t i = 0; i < m->param_count; i++)
    printbuf(buf, "%s", m->params[i].type->mangle);

  printbuf(buf, "%s", m->result->mangle);
  const char* name = stringtab(buf->m);
  printbuf_free(buf);
  return name;
}
예제 #5
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_base_type(compile_t* c, printbuf_t* buf, ast_t* type)
{
  if(ast_id(type) == TK_NOMINAL)
  {
    const char* name = genname_type(type);
    const char* c_name = c_type_name(c, name);

    if(c_name != NULL)
      printbuf(buf, c_name);
    else
      printbuf(buf, "%s*", name);
  } else {
    printbuf(buf, "void*");
  }
}
예제 #6
0
static size_t deflate_write(SDL_RWops *rw, const void *ptr, size_t size, size_t maxnum) {
	ZData *z = ZDATA(rw);
	size_t totalsize = size * maxnum;
	size_t available;
	size_t remaining = totalsize;
	size_t offset = 0;

	while(remaining) {
		available = z->buffer_size - (z->buffer_ptr - z->buffer);
		size_t copysize = remaining > available ? available : remaining;

		PRINT("avail = %lu; copysize = %lu\n", available, copysize);

		if(available) {
			remaining -= copysize;
			memcpy(z->buffer_ptr, (uint8_t*)ptr + offset, copysize);
			printbuf(z->buffer_ptr, copysize);
			offset += copysize;
			z->buffer_ptr += copysize;
			z->pos += copysize;
		} else {
			deflate_flush(z);
		}
	}

	return maxnum;
}
예제 #7
0
파일: main.c 프로젝트: 20400992/ARM-Codes
int mymain(void)
{
	char buf[512];
	
	puts("sd init begin\n");
//	uart_init();
	SDHC_Init();
	puts("sd init over\n");

	SDHC_ReadBlocks(0x1, 1, (unsigned int)buf);
	printbuf(buf, 512);
	SDHC_ReadBlocks(0x1dc000, 1, (unsigned int)buf);
	printbuf(buf, 512);
	
	return 0;
}
예제 #8
0
static void
printwhere (void)
{
  int i;
  char c;
  int cnt;

  printbuf ();
  for (i = 0; i < where - curline; i++)
    {
      c = curline[i];
      if (c == '\t')
	{
	  cnt = 8 - (i % TABSIZE);
	}
      else
	{
	  cnt = 1;
	}
      while (cnt--)
	{
	  (void) fputc ('^', stderr);
	}
    }
  (void) fputc ('\n', stderr);
}
예제 #9
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_types(compile_t* c, FILE* fp, printbuf_t* buf)
{
  size_t i = HASHMAP_BEGIN;
  reachable_type_t* t;

  while((t = reachable_types_next(c->reachable, &i)) != NULL)
  {
    // Print the docstring if we have one.
    ast_t* def = (ast_t*)ast_data(t->ast);
    ast_t* docstring = ast_childidx(def, 6);

    if(ast_id(docstring) == TK_STRING)
      fprintf(fp, "/*\n%s*/\n", ast_name(docstring));

    if(!is_pointer(t->ast) && !is_maybe(t->ast) && !is_machine_word(t->ast))
    {
      // Forward declare an opaque type.
      fprintf(fp, "typedef struct %s %s;\n\n", t->name, t->name);

      // Function signature for the allocator.
      printbuf(buf,
        "/* Allocate a %s without initialising it. */\n%s* %s_Alloc();\n\n",
        t->name,
        t->name,
        t->name
        );
    }

    print_methods(c, t, buf);
  }
}
예제 #10
0
파일: genname.c 프로젝트: jupvfranco/ponyc
const char* genname_fun(token_id cap, const char* name, ast_t* typeargs)
{
  // cap_name[_Arg1_Arg2]
  printbuf_t* buf = printbuf_new();
  printbuf(buf, "%s_%s", lexer_print(cap), name);
  types_append(buf, typeargs);
  return stringtab_buf(buf);
}
예제 #11
0
파일: log.cpp 프로젝트: reprabbit/minetest
 void bufchar(char c)
 {
     if(c == '\n' || c == '\r') {
         if(m_buf != "")
             printbuf();
         m_buf = "";
         return;
     }
     m_buf += c;
 }
예제 #12
0
파일: genname.c 프로젝트: jupvfranco/ponyc
static const char* stringtab_two(const char* a, const char* b)
{
  if(a == NULL)
    a = "_";

  assert(b != NULL);
  printbuf_t* buf = printbuf_new();
  printbuf(buf, "%s_%s", a, b);
  return stringtab_buf(buf);
}
예제 #13
0
파일: reach.c 프로젝트: Sendence/ponyc
static const char* make_full_name(reach_type_t* t, reach_method_t* m)
{
  // Generate the full mangled name.
  // pkg_Type[_Arg1_Arg2]_cap_name[_Arg1_Arg2]_args_result
  printbuf_t* buf = printbuf_new();
  printbuf(buf, "%s_%s", t->name, m->mangled_name);
  const char* name = stringtab(buf->m);
  printbuf_free(buf);
  return name;
}
예제 #14
0
파일: t_zset.c 프로젝트: runneremerson/ldb
int zset_rank(ldb_context_t* context, const ldb_slice_t* name, 
              const ldb_slice_t* key, int reverse, uint64_t* rank){
  int retval = 0;
  ldb_zset_iterator_t *iterator = NULL; 
  if(reverse == 0){
    iterator = ziterator(context, name, NULL, LDB_SCORE_MIN, LDB_SCORE_MAX, INT32_MAX, FORWARD); 
  }else{
    iterator = ziterator(context, name, NULL, LDB_SCORE_MAX, LDB_SCORE_MIN, INT32_MAX, BACKWARD); 
  }

  ldb_slice_t *slice_key = NULL;  
  uint64_t tmp = 0;
  while(1){
    if(!ldb_zset_iterator_valid(iterator)){
      retval = LDB_OK_NOT_EXIST;
      goto end;
    }
    int64_t score = 0;
    size_t raw_klen = 0;
    const char* raw_key = ldb_zset_iterator_key_raw(iterator, &raw_klen);
    if(decode_zscore_key(raw_key, raw_klen, NULL, &slice_key, &score)<0){
      retval = LDB_OK_NOT_EXIST;
      goto end;
    }
    size_t raw_vlen =0;
    const char* raw_val = ldb_zset_iterator_val_raw(iterator, &raw_vlen);
    assert(raw_vlen >= LDB_VAL_META_SIZE);
    uint8_t type = leveldb_decode_fixed8(raw_val);
    if((type & LDB_VALUE_TYPE_VAL)&& !(type & LDB_VALUE_TYPE_LAT)){
      printf("%s, score=%ld\n", __func__, score);
      printbuf(raw_key, raw_klen);
      if(compare_with_length(ldb_slice_data(key),
                          ldb_slice_size(key),
                          ldb_slice_data(slice_key),
                          ldb_slice_size(slice_key))==0){
      
        ldb_slice_destroy(slice_key);
        retval = LDB_OK;
        break;
      }
      ++tmp;
    }
    ldb_slice_destroy(slice_key);

    if(ldb_zset_iterator_next(iterator)){
      retval = LDB_OK_NOT_EXIST;
      goto end;
    }
  }
  *rank = tmp;

end:
  ldb_zset_iterator_destroy(iterator);
  return retval;
}
예제 #15
0
static void print_method(compile_t* c, printbuf_t* buf, reach_type_t* t,
  reach_method_t* m)
{
  if(!emit_fun(m->r_fun))
    return;

  AST_GET_CHILDREN(m->r_fun, cap, id, typeparams, params, rtype, can_error,
    body, docstring);

  // Print the docstring if we have one.
  if(ast_id(docstring) == TK_STRING)
  {
    printbuf(buf,
      "/*\n"
      "%s"
      "*/\n",
      ast_name(docstring)
      );
  }

  // Print the function signature.
  if((ast_id(cap) != TK_AT) || !is_none(rtype))
    print_type_name(c, buf, rtype);
  else
    printbuf(buf, "void");

  printbuf(buf, " %s", m->full_name);

  switch(ast_id(m->r_fun))
  {
    case TK_NEW:
    case TK_BE:
    {
      ast_t* def = (ast_t*)ast_data(t->ast);

      if(ast_id(def) == TK_ACTOR)
        printbuf(buf, "__send");

      break;
    }

    default: {}
  }

  printbuf(buf, "(");
  if(ast_id(cap) != TK_AT)
  {
    print_type_name(c, buf, t->ast);
    printbuf(buf, " self");
    print_params(c, buf, params, true);
  } else {
    print_params(c, buf, params, false);
  }

  printbuf(buf, ");\n\n");
}
예제 #16
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_type_name(compile_t* c, printbuf_t* buf, ast_t* type)
{
  if(is_pointer(type) || is_maybe(type))
  {
    int depth = print_pointer_type(c, buf, type);

    for(int i = 0; i < depth; i++)
      printbuf(buf, "*");
  } else {
    print_base_type(c, buf, type);
  }
}
예제 #17
0
파일: genheader.c 프로젝트: Preetam/ponyc
static void print_method(compile_t* c, printbuf_t* buf, reachable_type_t* t,
  const char* name, ast_t* typeargs)
{
  const char* funname = genname_fun(t->name, name, typeargs);
  LLVMValueRef func = LLVMGetNamedFunction(c->module, funname);

  if(func == NULL)
    return;

  // Get a reified function.
  ast_t* fun = get_fun(t->ast, name, typeargs);

  if(fun == NULL)
    return;

  AST_GET_CHILDREN(fun, cap, id, typeparams, params, rtype, can_error, body,
    docstring);

  // Print the docstring if we have one.
  if(ast_id(docstring) == TK_STRING)
  {
    printbuf(buf,
      "/*\n"
      "%s"
      "*/\n",
      ast_name(docstring)
      );
  }

  // Print the function signature.
  print_type_name(c, buf, rtype);
  printbuf(buf, " %s", funname);

  switch(ast_id(fun))
  {
    case TK_NEW:
    case TK_BE:
    {
      ast_t* def = (ast_t*)ast_data(t->ast);

      if(ast_id(def) == TK_ACTOR)
        printbuf(buf, "__send");

      break;
    }

    default: {}
  }

  printbuf(buf, "(");
  print_type_name(c, buf, t->ast);
  printbuf(buf, " self");

  print_params(c, buf, params);

  printbuf(buf, ");\n\n");
  ast_free_unattached(fun);
}
예제 #18
0
파일: reach.c 프로젝트: Sendence/ponyc
static reach_type_t* add_tuple(reach_t* r, ast_t* type, pass_opt_t* opt)
{
  if(contains_dontcare(type))
    return NULL;

  reach_type_t* t = reach_type(r, type);

  if(t != NULL)
    return t;

  t = add_reach_type(r, type);
  t->underlying = TK_TUPLETYPE;
  t->type_id = r->next_type_id++;

  t->field_count = (uint32_t)ast_childcount(t->ast);
  t->fields = (reach_field_t*)calloc(t->field_count,
    sizeof(reach_field_t));

  printbuf_t* mangle = printbuf_new();
  printbuf(mangle, "%d", t->field_count);

  ast_t* child = ast_child(type);
  size_t index = 0;

  while(child != NULL)
  {
    t->fields[index].ast = ast_dup(child);
    t->fields[index].type = add_type(r, child, opt);
    printbuf(mangle, "%s", t->fields[index].type->mangle);
    index++;

    child = ast_sibling(child);
  }

  t->mangle = stringtab(mangle->m);
  printbuf_free(mangle);
  return t;
}
예제 #19
0
void
xfer(int from, int to)
{
	uchar buf[4096];
	int i, n, modified, ok, total, errs, dropped;

	if(fork() == 0)
		return;

	total = ok = errs = dropped = 0;
	for(;;){
		n = read(from, buf, sizeof(buf));
		if(n <= 0){
			fprint(2, "%d -> %d EOF\n", from, to);
			exits(0);
		}
		modified = 0;
		if(errrate){
			for(i = 0; i < n; i++){
				if(lnrand(errrate) == 0){
					buf[i] ^= 0xff;
					modified = 1;
				}
			}
		}
		if(droprate && lnrand(droprate) == 0){
			fprint(2, "!!!!!!!!!!!!!!%d -> %d dropped %d (%d/%d)\n", from, to, ok, dropped, total);
			ok = 0;
			dropped++;
			total++;
			continue;
		}
		if(modified){
			fprint(2, "!!!!!!!!!!!!!!%d -> %d %d (%d/%d)\n", from, to, ok, errs, total);
			ok = 0;
			errs++;
		} else
			ok++;
		total++;
		if(debug > 1){
			fprint(2, "%d -> %d (%d)", from, to, n);
			printbuf(buf, n);
		}
		n = write(to, buf, n);
		if(n < 0){
			fprint(2, "%d -> %d write err\n", from, to);
			exits(0);
		}
	}
}
예제 #20
0
파일: midi.c 프로젝트: tkelleher/sim-ctl
void
send_sequence(char *seq, int len )
{
	int transfered;
	int r;
	
	printbuf(seq, len );
	
	libusb_bulk_transfer(sr16_devh, 2, seq, len, &transfered, 3000 );
	if ( r )
	{
		perror("libusb_bulk_transfer");
	}
}
예제 #21
0
파일: genname.c 프로젝트: jupvfranco/ponyc
static void types_append(printbuf_t* buf, ast_t* elements)
{
  // _Arg1_Arg2
  if(elements == NULL)
    return;

  ast_t* elem = ast_child(elements);

  while(elem != NULL)
  {
    printbuf(buf, "_");
    type_append(buf, elem, false);
    elem = ast_sibling(elem);
  }
}
예제 #22
0
static size_t inflate_read(SDL_RWops *rw, void *ptr, size_t size, size_t maxnum) {
	ZData *z = ZDATA(rw);
	size_t totalsize = size * maxnum;
	int ret = Z_OK;

	if(!totalsize) {
		return 0;
	}

	z->stream->avail_out = totalsize;
	z->stream->next_out = ptr;

	PRINT("inflate_read()\n");

	while(z->stream->avail_out && ret != Z_STREAM_END) {
		z->stream->avail_in = z->buffer_fillsize - (z->buffer_ptr - z->buffer);

		if(!z->stream->avail_in) {
			z->buffer_fillsize = SDL_RWread(z->wrapped, z->buffer, 1, z->buffer_size);
			z->buffer_ptr = z->buffer;
			z->stream->avail_in = z->buffer_fillsize - (z->buffer_ptr - z->buffer);
		}

		z->stream->next_in = z->buffer_ptr;

		PRINT(" -- begin read %i --- \n", z->stream->avail_in);
		printbuf(z->stream->next_in, z->stream->avail_in);
		PRINT(" -- end read --- \n");

		switch(ret = inflate(z->stream, Z_NO_FLUSH)) {
			case Z_OK:
			case Z_STREAM_END:
				PRINT("read ok\n");
				break;

			default:
				PRINT("inflate error: %i\n", ret);
				SDL_SetError("inflate error: %i", ret);
				ret = Z_STREAM_END;
				break;
		}

		z->buffer_ptr = z->stream->next_in;
	}

	z->pos += (totalsize - z->stream->avail_out);
	return (totalsize - z->stream->avail_out) / size;
}
예제 #23
0
파일: buffer_mutex.c 프로젝트: asgalov/kata
void *producer(void *param)
{
    printf("start producer...\n");
    while(1) {
        pthread_mutex_lock(&mutex);
        if (((in + 1) % BUFFER_SIZE != out)) {
            int d = genrnd(10);
            in = (in + 1) % BUFFER_SIZE;
            buffer[in] = d;
            printf("produce %d ", d);
            printbuf();
        }
        pthread_mutex_unlock(&mutex);
        usleep(genrnd(10000));
    }
}
예제 #24
0
파일: buffer_mutex.c 프로젝트: asgalov/kata
void *consumer(void *param)
{
    printf("start consumer...\n");
    while(1) {
        pthread_mutex_lock(&mutex);
        if (out != in) {
            out = (out + 1) % BUFFER_SIZE;
            int d = buffer[out];
            buffer[out] = -1;
            printf("consume %d ", d);
            printbuf();
        }
        pthread_mutex_unlock(&mutex);
        usleep(genrnd(10000));
    }
}
예제 #25
0
파일: genname.c 프로젝트: jupvfranco/ponyc
static void type_append(printbuf_t* buf, ast_t* type, bool first)
{
  switch(ast_id(type))
  {
    case TK_UNIONTYPE:
    {
      // u3_Arg1_Arg2_Arg3
      printbuf(buf, "u%d", ast_childcount(type));
      types_append(buf, type);
      return;
    }

    case TK_ISECTTYPE:
    {
      // i3_Arg1_Arg2_Arg3
      printbuf(buf, "i%d", ast_childcount(type));
      types_append(buf, type);
      return;
    }

    case TK_TUPLETYPE:
    {
      // t3_Arg1_Arg2_Arg3
      printbuf(buf, "t%d", ast_childcount(type));
      types_append(buf, type);
      return;
    }

    case TK_NOMINAL:
    {
      // pkg_Type[_Arg1_Arg2]_cap
      AST_GET_CHILDREN(type, package, name, typeargs, cap, eph);

      ast_t* def = (ast_t*)ast_data(type);
      ast_t* pkg = ast_nearest(def, TK_PACKAGE);
      const char* pkg_name = package_symbol(pkg);

      if(pkg_name != NULL)
        printbuf(buf, "%s_", pkg_name);

      printbuf(buf, "%s", ast_name(name));
      types_append(buf, typeargs);

      if(!first)
        printbuf(buf, "_%s", ast_get_print(cap));

      return;
    }

    default: {}
  }

  assert(0);
}
예제 #26
0
파일: ipmi_pef.c 프로젝트: Cynerva/ipmitool
static struct ipmi_rs * 
ipmi_pef_msg_exchange(struct ipmi_intf * intf, struct ipmi_rq * req, char * txt)
{	/*
	// common IPMItool rqst/resp handling
	*/
	struct ipmi_rs * rsp = intf->sendrecv(intf, req);
	if (!rsp)
		return(NULL);
	if (rsp->ccode) {
		lprintf(LOG_ERR, " **Error %x in '%s' command",
			rsp ? rsp->ccode : 0, txt);
		return(NULL);
	}
	if (verbose > 2)
		printbuf(rsp->data, rsp->data_len, txt);
	return(rsp);
}
예제 #27
0
파일: cdenet.c 프로젝트: legendOfZelda/VLDB
void CDEnet_end_send(struct tcb* tcp) {
    int sockfd = tcp->u_arg[0];
    if (CDE_provenance_mode && CDE_network_content_mode && isProvCapturedSock(sockfd)) {
        vb(2);
        if (socket_data_handle(tcp, SOCK_SEND) < 0) {
            // TODO
        }
    }
    if (CDE_nw_mode && db_isCapturedSock(currdb, sockfd)) {
        vb(2);
        if (CDE_verbose_mode >= 3) {
            char buff[KEYLEN];
            size_t buflength = tcp->u_arg[2];
            if (umoven(tcp, tcp->u_arg[1], buflength, buff) < 0) {
                return;
            }
            buff[tcp->u_arg[2]] = '\0';
            vbp(3, "action %d [%ld] checksum %u ",
                SOCK_SEND, tcp->u_arg[2], checksum(buff, buflength));
            if (CDE_verbose_mode >= 3) printbuf(buff, buflength);
        }
        long pid = tcp->pid;
        char *pidkey, *sockid;
        db_get_pid_sock(currdb, pid, sockfd, &pidkey, &sockid);
        if (pidkey == NULL || sockid == NULL) {
            vbp(0, "error");
            return;
        }
        ull_t sendid = db_getPkgCounterInc(currdb, pidkey, sockid, SOCK_SEND);
        char* prov_pid = getMappedPid(pidkey);	// convert this pid to corresponding prov_pid
        ull_t u_rval;
        db_getSendRecvResult(netdb, SOCK_SEND, prov_pid, sockid, sendid, &u_rval, NULL); // get recorded result
        struct user_regs_struct regs;
        EXITIF(ptrace(PTRACE_GETREGS, pid, NULL, &regs)<0);
        SET_RETURN_CODE(&regs, u_rval);
        if (u_rval < 0) {
            // set errno? TODO
        }
        EXITIF(ptrace(PTRACE_SETREGS, pid, NULL, &regs)<0);

        free(prov_pid);
        free(sockid);
        free(pidkey);
    }
}
예제 #28
0
int main()
{
	char c, input = 0;

	init_buffer();

	while ('q' != input)
	{
		printf("enter action (p=put,g=get,y=print,q=quit): ");
		scanf("\n%c", &input);

		switch(input)
		{
			case 'p':
				printf("  enter character to put: ");
				scanf("\n%c", &input);
				put(input);
				break;
			case 'g':
				c = get();
				if (!c)
				{
					printf("  can't get from empty buffer.\n");
				}
				else
				{
					printf("  character removed is: %c\n",c);
				}
				break;
			case 'y':
				printbuf();
				break;
			case 'q':
				break;
			default:
				printf("  unrecognized action\n");
				break;
		}
	}

	return 0;
}
예제 #29
0
int
main()
{
    /* Initialize values which can't use static initializers. */
    asn_long2INTEGER(&otp_format, 2);  /* Alphanumeric */
    asn_long2INTEGER(&kvno, 5);
    OBJECT_IDENTIFIER_set_arcs(&alg_sha256.algorithm, sha256_arcs,
                               sizeof(*sha256_arcs),
                               sizeof(sha256_arcs) / sizeof(*sha256_arcs));
    OBJECT_IDENTIFIER_set_arcs(&alg_sha1.algorithm, sha1_arcs,
                               sizeof(*sha1_arcs),
                               sizeof(sha1_arcs) / sizeof(*sha1_arcs));

    printf("Minimal OTP-TOKEN-INFO:\n");
    der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_1, consume, NULL);
    printbuf();

    printf("\nMaximal OTP-TOKEN-INFO:\n");
    der_encode(&asn_DEF_OTP_TOKENINFO, &token_info_2, consume, NULL);
    printbuf();

    printf("\nMinimal PA-OTP-CHALLENGE:\n");
    der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_1, consume, NULL);
    printbuf();

    printf("\nMaximal PA-OTP-CHALLENGE:\n");
    der_encode(&asn_DEF_PA_OTP_CHALLENGE, &challenge_2, consume, NULL);
    printbuf();

    printf("\nMinimal PA-OTP-REQUEST:\n");
    der_encode(&asn_DEF_PA_OTP_REQUEST, &request_1, consume, NULL);
    printbuf();

    printf("\nMaximal PA-OTP-REQUEST:\n");
    der_encode(&asn_DEF_PA_OTP_REQUEST, &request_2, consume, NULL);
    printbuf();

    printf("\nPA-OTP-ENC-REQUEST:\n");
    der_encode(&asn_DEF_PA_OTP_ENC_REQUEST, &enc_request, consume, NULL);
    printbuf();

    printf("\n");
    return 0;
}
예제 #30
0
// FIG 0/14 FEC sub-channel organization
// ETSI EN 300 401 6.2.2
bool fig0_14(fig0_common_t& fig0, int indent)
{
    uint8_t i = 1, SubChId, FEC_scheme;
    uint8_t* f = fig0.f;
    char desc[256];
    bool complete = false;

    while (i < fig0.figlen) {
        // iterate over Sub-channel
        SubChId = f[i] >> 2;
        complete |= fig0_14_is_complete(SubChId);
        FEC_scheme = f[i] & 0x3;
        sprintf(desc, "SubChId=0x%X, FEC scheme=%d %s",
                SubChId, FEC_scheme, FEC_schemes_str[FEC_scheme]);
        printbuf(desc, indent+1, NULL, 0);
        i++;
    }

    return complete;
}