int main(void)
{
  struct taia taia;
  char stamp[TAIA_TAI64N + 1];
  char ch;

  stamp[0] = '@';
  for (;;) {
    if (buffer_get(buffer0, &ch, 1) != 1) { done(); goto FINISH; }
    taia_now(&taia);
    taia_tai64n(stamp + 1, &taia);

    stamp[sizeof(stamp) - 1] = ' ';
    buffer_put(buffer1, stamp, sizeof(stamp));

    for (;;) {
      buffer_put(buffer1, &ch, 1);
      if (ch == '\n') break;
      if (buffer_get(buffer0, &ch, 1) != 1) { done(); goto FINISH; }
    }
  }

  FINISH:
  return 0;
}

/**
 * Parses a Content-Length header value.
 */
int parse_header_content_length(struct parser *p) {
    char c, *buffer;
    int i, m, r;

    if (ready(p) < 3)
        return PARSING_WAIT;
    c = buffer_get(&(p->buffer), p->mark);

    for (m = 1; isdigit(c) || c == ' ' || c == '\t'; m++) {
        if (ready(p) < 3 + m)
            return PARSING_WAIT;
        c = buffer_get(&(p->buffer), p->mark + m);
    }

    buffer = buffer_copy(&(p->buffer), p->mark, m - 1);
    if (buffer == NULL) {
        p->error = E_MEMORY;
        return PARSING_ERROR;
    }
    advance_mark(p, m - 1);

    r = parse_constant(p, CRLF, 2);
    if (r != PARSING_DONE) {
        free(buffer);
        return r;
    }

    errno = 0;
    p->request.content_length = strtol(buffer, NULL, 10);
    free(buffer);
    return (errno == 0) ? PARSING_DONE : PARSING_ERROR;
}

main()
{
  int pid;
  int wstat;
  char ch;

  sig_ignore(sig_pipe);

  pid = fork();
  if (pid == -1) strerr_die2sys(111,"mconnect-io: fatal: ","unable to fork: ");

  if (!pid) {
    buffer_init(&bin,myread,0,inbuf,sizeof inbuf);
    buffer_init(&bout,write,7,outbuf,sizeof outbuf);

    while (buffer_get(&bin,&ch,1) == 1) {
      if (ch == '\n') buffer_put(&bout,"\r",1);
      buffer_put(&bout,&ch,1);
    }
    _exit(0);
  }

  buffer_init(&bin,myread,6,inbuf,sizeof inbuf);
  buffer_init(&bout,write,1,outbuf,sizeof outbuf);

  while (buffer_get(&bin,&ch,1) == 1)
    buffer_put(&bout,&ch,1);

  kill(pid,sig_term);
  wait_pid(&wstat,pid);

  _exit(0);
}

static int
trace_free (void *buf)
{
  uintptr_t ptr = buffer_get(uintptr_t);
  uintptr_t caller = buffer_get(uintptr_t);
  unsigned long long time = buffer_get(unsigned long long);

  int res = memory_free(ptr, caller, time);
  assert_inner(!res, "memory_free");

  return 0;
}

static int
trace_enter (void *buf)
{
  uintptr_t func = buffer_get(uintptr_t);
  uintptr_t caller = buffer_get(uintptr_t);
  unsigned long long time = buffer_get(unsigned long long);

  int res = function_enter(func, caller, time);
  assert_inner(!res, "function_enter");

  return 0;
}

static int
trace_malloc (void *buf)
{
  size_t size = buffer_get(size_t);
  uintptr_t caller = buffer_get(uintptr_t);
  uintptr_t result = buffer_get(uintptr_t);
  unsigned long long time = buffer_get(unsigned long long);

  int res = memory_malloc(size, caller, result, time);
  assert_inner(!res, "memory_malloc");

  return 0;
}

void CAN_start_transmission_internal(volatile can_stream_data_t* data) {
	int i=0;
	
	while ((buffer_bytes_available((buffer_t*)&data->byte_buffer)>0) && i<8) {
		data->can_msg.data.u8[i]=buffer_get((buffer_t*)&data->byte_buffer);
		i++;
	}
	if (i==0) { // nothing left to transmit
		data->transmission_active=false;
		return;
	}
	/*
	if (data->can_channel==0) {
		can_bus_init(data->can_channel, ((uint32_t)&mob_ram_ch0[0]), CANIF_CHANNEL_MODE_NORMAL, can_callback0);
	} else {
		can_bus_init(data->can_channel, ((uint32_t)&mob_ram_ch1[0]), CANIF_CHANNEL_MODE_NORMAL, can_callback1);
	}
	*/
	data->can_mob.handle=CAN_TX_MOB;
	data->can_mob.dlc=i;
	data->can_msg.id=data->id;
	data->can_msg.id_mask = data->id_mask;
	data->can_mob.req_type=CAN_DATA_FRAME;
	data->transmission_active=true;
	can_bus_tx(data->can_channel,
	       data->can_mob.handle,
	       data->can_mob.dlc,
	       data->can_mob.req_type,
	       data->can_mob.can_msg);
}

void mkinvalid_secret(PCPCTX *ptx, pcp_key_t *k, int type) {
  pcp_key_t *key = ucmalloc(sizeof(pcp_key_t));
  memcpy(key, k, sizeof(pcp_key_t));
  FILE *fd = NULL;

    fprintf(stderr, "fd test %d\n", type);

  switch(type) {
  case 0:
    key->version = 0;
    fd = F("testkey-wrong-version");
    break;
  case 1:
    key->serial = 0;
    fd = F("testkey-wrong-serial");
    break;
  case 2:
    key->ctime = 0;
    fd = F("testkey-invalid-ctime");
    break;
  }

  if(fd != NULL) {
    pcp_dumpkey(key);
    Buffer *b = pcp_export_secret(ptx, key, "xxx");
    fwrite(buffer_get(b), 1, buffer_size(b), fd);
    fclose(fd);
  }
  else {
    fprintf(stderr, "fd not opened for test %d\n", type);
  }

  free(key);
}

void mkinvalid_public(PCPCTX *ptx, pcp_key_t *k, int type) {
  pcp_key_t *key = ucmalloc(sizeof(pcp_key_t));
  memcpy(key, k, sizeof(pcp_key_t));
  FILE *fd = NULL;

  switch(type) {
  case 0:
    key->type = 0;
    fd = F("testpubkey-wrong-type");
    break;
  case 1:
    key->version = 0;
    fd = F("testpubkey-wrong-version");
    break;
  case 2:
    key->serial = 0;
    fd = F("testpubkey-wrong-serial");
    break;
  case 3:
    key->ctime = 0;
    fd = F("testpubkey-invalid-ctime");
    break;
  }

  if(fd != NULL) {
    Buffer *b = pcp_export_rfc_pub(ptx, key);
    fwrite(buffer_get(b), 1, buffer_size(b), fd);
    fclose(fd);
  }

  free(key);
}

/* Find section header based on ignored section name */
static Elf64_Shdr *find_ignored_section_header(struct parsed_elf *pelf,
					       const char *ignore_section)
{
	int i;
	const char *shstrtab;

	/* No section needs to be ignored */
	if (ignore_section == NULL)
		return NULL;

	DEBUG("Section to be ignored: %s\n", ignore_section);

	/* Get pointer to string table */
	shstrtab = buffer_get(pelf->strtabs[pelf->ehdr.e_shstrndx]);

	for (i = 0; i < pelf->ehdr.e_shnum; i++) {
		Elf64_Shdr *shdr;
		const char *section_name;

		shdr = &pelf->shdr[i];
		section_name = &shstrtab[shdr->sh_name];

		/* If section name matches ignored string, return shdr */
		if (strcmp(section_name, ignore_section) == 0)
			return shdr;
	}

	/* No section matches ignore string */
	return NULL;
}

static void* consumer_operation()
{
	set_signal_mask();
	while(status_on)
	{	
	 	if(pthread_mutex_lock(&buffer_lock_mtx)!=0)
			print_log(WARNING,"\nthere is error in lock cons");
		
		while(is_buffer_empty())
		{	
			if(pthread_cond_wait(&buffer_not_empty_cond,&buffer_lock_mtx)!=0)
				print_log(WARNING,"\nthere is error in wait cons");
		}	

		int peer_sfd = buffer_get();

		if(peer_sfd < 0) 
		{
			print_log(WARNING,"\nRECIEVED FAILED ACCEPT SOCKET");
			pthread_mutex_unlock(&buffer_lock_mtx)!=0;
			continue;
		}

		if(pthread_cond_broadcast(&buffer_not_full_cond)!=0)
			print_log(WARNING,"\nthere is error in broadcast cons");
		if(pthread_mutex_unlock(&buffer_lock_mtx)!=0)
			print_log(WARNING,"\nthere is error in unlock cons");

		manage_single_request(peer_sfd);
		close(peer_sfd);
	}
	pthread_exit(pthread_self);
}

void doit()
{
  char ch;
  int match = 1;
  long linenum = 0;
  stralloc fifoline = { 0 };

  linenum = 0;

  /* try duming data in 23 seconds */
  alarm(dumpfreq);

  buffer_putsflush(buffer_2, ARGV0 "entering main loop\n");

  /* forever read from pipe line by line and handle it */
  while(1)
    {
      while(match) 
	{
	  if(flagdumpasap == 1) 
	    dumpcheck(flagdumpasap, flagchanged, flagchildrunning, flagsighup);

	  ++linenum;
	  if(buffer_get(&wr, &ch, 1) == 1)
	    {
	      if(getln(&wr, &fifoline, &match, '\n') == -1)
		continue;
	      buffer_put(buffer_2, &ch, 1);
	      buffer_putflush(buffer_2, fifoline.s, fifoline.len);
	      handle_line(&fifoline, ch);
	    }
	}
    }
}

/**
 * Parses a header value. Deprecated header line folding is not supported.
 */
int parse_header_value(struct parser *p) {
    char c;

    if (ready(p) < 3)
        return PARSING_WAIT;
    c = buffer_get(&(p->buffer), p->mark);

    while (isgraph(c) || c == ' ' || c == '\t') {
        advance_mark(p, 1);
        if (ready(p) < 3)
            return PARSING_WAIT;
        c = buffer_get(&(p->buffer), p->mark);
    }

    return parse_constant(p, CRLF, 2);
}

/**
 * @internal
 *
 * @brief Verify the hmac of a packet
 *
 * @param  session      The session to use.
 * @param  buffer       The buffer to verify the hmac from.
 * @param  mac          The mac to compare with the hmac.
 *
 * @return              0 if hmac and mac are equal, < 0 if not or an error
 *                      occured.
 */
int packet_hmac_verify(SSH_SESSION *session, BUFFER *buffer,
    unsigned char *mac) {
  unsigned char hmacbuf[EVP_MAX_MD_SIZE] = {0};
  HMACCTX ctx;
  unsigned int len;
  u32 seq;

  ctx = hmac_init(session->current_crypto->decryptMAC, 20, HMAC_SHA1);
  if (ctx == NULL) {
    return -1;
  }

  seq = htonl(session->recv_seq);

  hmac_update(ctx, (unsigned char *) &seq, sizeof(u32));
  hmac_update(ctx, buffer_get(buffer), buffer_get_len(buffer));
  hmac_final(ctx, hmacbuf, &len);

#ifdef DEBUG_CRYPTO
  ssh_print_hexa("received mac",mac,len);
  ssh_print_hexa("Computed mac",hmacbuf,len);
  ssh_print_hexa("seq",(unsigned char *)&seq,sizeof(u32));
#endif
  if (memcmp(mac, hmacbuf, len) == 0) {
    return 0;
  }

  return -1;
}

static int next (unsigned char *c, void *p)
{
  register int r = buffer_get((buffer *)p, (char *)c, 1) ;
  if (r < 0) return 0 ;
  if (!r) *c = 0 ;
  return 1 ;
}

/* this is a public key in openssh's format */
static STRING *make_rsa1_string(STRING *e, STRING *n){
  BUFFER *buffer = NULL;
  STRING *rsa = NULL;
  STRING *ret = NULL;

  buffer = buffer_new();
  rsa = string_from_char("ssh-rsa1");

  if (buffer_add_ssh_string(buffer, rsa) < 0) {
    goto error;
  }
  if (buffer_add_ssh_string(buffer, e) < 0) {
    goto error;
  }
  if (buffer_add_ssh_string(buffer, n) < 0) {
    goto error;
  }

  ret = string_new(buffer_get_len(buffer));
  if (ret == NULL) {
    goto error;
  }

  string_fill(ret, buffer_get(buffer), buffer_get_len(buffer));
error:
  buffer_free(buffer);
  string_free(rsa);

  return ret;
}

static void *ihy_playing(void *data)
{
    /* contains uncompressed data, (ihy_buffer_content *) */
    t_buffer buffer = ((struct ihy_streaming_data *)data)->buffer;
    ihy_data *ihy = ((struct ihy_streaming_data *)data)->ihy;
    ao_device *audio_device;
    struct ihy_buffer_content *to_play;

    audio_device = ao_init_device(16, ihy->Channels, ihy->Frequency);

    /* we need to ensure that the other thread has added,
     * at least, 1 element
     */
    while (buffer_isempty(buffer))
	usleep(50000);
    while (!buffer_isempty(buffer))
    {
	to_play = buffer_get(buffer);
	ao_play_samples(audio_device, to_play->samples, to_play->samplesSize);
	free(to_play->samples);
	free(to_play); /* hum quite dangerous */
    }
    ao_close_device(audio_device);
    return NULL;
}

int main(void)
{
	clock_setup();
	gpio_setup();
	usart_setup();
	spi_setup();
	buffer_init(send_buffer,BUFFER_SIZE);
	buffer_init(receive_buffer,BUFFER_SIZE);
	usart_enable_tx_interrupt(USART1);

/* Send a greeting message on USART1. */
	usart_print_string("SD Card SPI Mode Test\r\n");

	while (1)
	{
/* Command interface */
        if (buffer_input_available(receive_buffer))
        {
            char character = buffer_get(receive_buffer);
            if (character == 0x0D)
            {
                line[characterPosition] = 0;
                characterPosition = 0;
                parseCommand(line);
            }
            else line[characterPosition++] = character;
        }
	}

	return 0;
}

static int doit(stralloc *out,int s,char ipremote[16],uint16 portremote,char iplocal[16],uint16 portlocal,unsigned int timeout,uint32 netif)
{
  buffer b;
  char bspace[128];
  char strnum[FMT_ULONG];
  int numcolons;
  char ch;

  if (socket_bind6(s,iplocal,0,netif) == -1) return -1;
  if (timeoutconn6(s,ipremote,113,timeout,netif) == -1) return -1;

  buffer_init(&b,mywrite,s,bspace,sizeof bspace);
  buffer_put(&b,strnum,fmt_ulong(strnum,portremote));
  buffer_put(&b," , ",3);
  buffer_put(&b,strnum,fmt_ulong(strnum,portlocal));
  buffer_put(&b,"\r\n",2);
  if (buffer_flush(&b) == -1) return -1;

  buffer_init(&b,myread,s,bspace,sizeof bspace);
  numcolons = 0;
  for (;;) {
    if (buffer_get(&b,&ch,1) != 1) return -1;
    if ((ch == ' ') || (ch == '\t') || (ch == '\r')) continue;
    if (ch == '\n') return 0;
    if (numcolons < 3) {
      if (ch == ':') ++numcolons;
    }
    else {
      if (!stralloc_append(out,&ch)) return -1;
      if (out->len > 256) return 0;
    }
  }
}

s08 buffer_getLine (buffer_struct *rb, char *s )
{
	// Devuelve lineas enteras del buffer.
	// El s debe tener capacidad suficiente.

s08 res = FALSE;
char cChar;

	if ( buffer_empty ( &xUart0RxedCharsBuffer )) {
		// No hay datos.
		res = FALSE;
	} else {
		// Copio vaciando el ringBuffer hasta encontrar un CR.
		while(1) {
			cChar = buffer_get(&xUart0RxedCharsBuffer);
			*(s++) = cChar;
			if ( (cChar == '\n') || (cChar == NULL))
				break;
		}
		*(s++) = '\0';
		res = TRUE;
	}
	return (res);

}