コード例 #1
0
ファイル: parse.c プロジェクト: as2120/ZAchieve
int vbuf__append_quoted1035(vbuf *vb, const byte *buf, int len)
{
    char qbuf[10];
    int i, ch;

    while (len)
    {
        qbuf[0]= 0;
        for (i=0; i<len; i++)
        {
            ch= buf[i];
            if (ch <= ' ' || ch >= 127)
            {
                sprintf(qbuf,"\\%03o",ch);
                break;
            }
            else if (!ctype_domainunquoted(ch))
            {
                sprintf(qbuf,"\\%c",ch);
                break;
            }
        }
        if (!adns__vbuf_append(vb,buf,i) || !adns__vbuf_append(vb,qbuf,strlen(qbuf)))
            return 0;
        if (i<len) i++;
        buf+= i;
        len-= i;
    }
    return 1;
}
コード例 #2
0
ファイル: general.c プロジェクト: as2120/ZAchieve
const char *adns__diag_domain(adns_state ads, int serv, adns_query qu,
                              vbuf *vb, const byte *dgram,
                              int dglen, int cbyte)
{
    adns_status st;

    st= adns__parse_domain(ads,serv,qu,vb, pdf_quoteok,
                           dgram,dglen,&cbyte,dglen);
    if (st == adns_s_nomemory)
    {
        return "<cannot report domain... out of memory>";
    }
    if (st)
    {
        vb->used= 0;
        if (!(adns__vbuf_appendstr(vb,"<bad format... ") &&
                adns__vbuf_appendstr(vb,adns_strerror(st)) &&
                adns__vbuf_appendstr(vb,">") &&
                adns__vbuf_append(vb,"",1)))
        {
            return "<cannot report bad format... out of memory>";
        }
    }
    if (!vb->used)
    {
        adns__vbuf_appendstr(vb,"<truncated ...>");
        adns__vbuf_append(vb,"",1);
    }
    return vb->buf;
}
コード例 #3
0
adns_status adns__parse_domain_more(findlabel_state *flstate, adns_state ads,
				    adns_query qu, vbuf *vb, parsedomain_flags flags,
				    const byte *dgram) {
  int lablen, labstart, i, ch, first;
  adns_status st;

  first= 1;
  for (;;) {
    st= adns__findlabel_next(flstate,&lablen,&labstart);
    if (st) return st;
    if (lablen<0) { vb->used=0; return adns_s_ok; }
    if (!lablen) break;
    if (first) {
      first= 0;
    } else {
      if (!adns__vbuf_append(vb,".",1)) return adns_s_nomemory;
    }
    if (flags & pdf_quoteok) {
      if (!vbuf__append_quoted1035(vb,dgram+labstart,lablen))
	return adns_s_nomemory;
    } else {
      ch= dgram[labstart];
      if (!ctype_alpha(ch) && !ctype_digit(ch)) return adns_s_answerdomaininvalid;
      for (i= labstart+1; i<labstart+lablen; i++) {
	ch= dgram[i];
	if (ch != '-' && !ctype_alpha(ch) && !ctype_digit(ch))
	  return adns_s_answerdomaininvalid;
      }
      if (!adns__vbuf_append(vb, (const char *) dgram+labstart,lablen))
	return adns_s_nomemory;
    }
  }
  if (!adns__vbuf_append(vb,"",1)) return adns_s_nomemory;
  return adns_s_ok;
}
コード例 #4
0
ファイル: transmit.c プロジェクト: Cloudxtreme/ircd-ratbox
void adns__querysend_tcp(adns_query qu, struct timeval now) {
  byte length[2];
#if 0
  struct iovec iov[2];
#endif
  int wr, wr2 = 0, r;
  adns_state ads;

  if (qu->ads->tcpstate != server_ok) return;

  assert(qu->state == query_tcpw);

  length[0]= (qu->query_dglen&0x0ff00U) >>8;
  length[1]= (qu->query_dglen&0x0ff);

  ads= qu->ads;
  if (!adns__vbuf_ensure(&ads->tcpsend,ads->tcpsend.used+qu->query_dglen+2)) return;

  qu->retries++;

  /* Reset idle timeout. */
  ads->tcptimeout.tv_sec= ads->tcptimeout.tv_usec= 0;

  if (ads->tcpsend.used) {
    wr= 0;
  } else {
#if 0
    iov[0].iov_base= (char *)length;
    iov[0].iov_len= 2;
    iov[1].iov_base= (char *)qu->query_dgram;
    iov[1].iov_len= qu->query_dglen;
    wr= writev(qu->ads->tcpsocket,iov,2);
#endif
    wr = write(qu->ads->tcpsocket, (char *)length, 2);
    if (wr > 0)
        wr2 = write(qu->ads->tcpsocket, (char *)qu->query_dgram, qu->query_dglen);

    if (wr < 0 || wr2 < 0) {
      if (!(errno == EAGAIN || errno == EINTR || errno == ENOSPC ||
	    errno == ENOBUFS || errno == ENOMEM)) {
	adns__tcp_broken(ads,"write",strerror(errno));
	return;
      }
      wr= 0;
    }
  }

  if (wr<2) {
    r= adns__vbuf_append(&ads->tcpsend,length,2-wr); assert(r);
    wr= 0;
  } else {
    wr-= 2;
  }
  if (wr<qu->query_dglen) {
    r= adns__vbuf_append(&ads->tcpsend,qu->query_dgram+wr,qu->query_dglen-wr); assert(r);
  }
}
コード例 #5
0
ファイル: general.c プロジェクト: hoangduit/reactos
adns_status adns_rr_info(adns_rrtype type,
			 const char **rrtname_r, const char **fmtname_r,
			 int *len_r,
			 const void *datap, char **data_r) {
  const typeinfo *typei;
  vbuf vb;
  adns_status st;

  typei= adns__findtype(type);
  if (!typei) return adns_s_unknownrrtype;

  if (rrtname_r) *rrtname_r= typei->rrtname;
  if (fmtname_r) *fmtname_r= typei->fmtname;
  if (len_r) *len_r= typei->rrsz;

  if (!datap) return adns_s_ok;

  adns__vbuf_init(&vb);
  st= typei->convstring(&vb,datap);
  if (st) goto x_freevb;
  if (!adns__vbuf_append(&vb,(byte*)"",1)) { st= adns_s_nomemory; goto x_freevb; }
  assert((int)strlen((char*)vb.buf) == vb.used-1);
  *data_r= realloc(vb.buf, (size_t) vb.used);
  if (!*data_r) *data_r= (char*)vb.buf;
  return adns_s_ok;

 x_freevb:
  adns__vbuf_free(&vb);
  return st;
}
コード例 #6
0
ファイル: hcommon.c プロジェクト: kbandla/adns
int Hwritev(int fd, const struct iovec *vector, size_t count) {
    size_t i;
    vbw.used= 0;
    for (i=0; i<count; i++, vector++) {
        if (!adns__vbuf_append(&vbw,vector->iov_base,vector->iov_len)) Tnomem();
    }
    return Hwrite(fd,vbw.buf,vbw.used);
}
コード例 #7
0
ファイル: general.c プロジェクト: hoangduit/reactos
int adns__vbuf_appendstr(vbuf *vb, const char *data) {
  int l;
  l= strlen(data);
  return adns__vbuf_append(vb,(byte*)data,l);
}
コード例 #8
0
ファイル: adnstransmit.c プロジェクト: DarkSpiritNET/NeoStats
void adns__querysend_tcp(adns_query qu, struct timeval now)
{
	byte length[2];
#ifndef WIN32
	struct iovec iov[2];
#endif
	int wr, r;
	adns_state ads;

	if (qu->ads->tcpstate != server_ok)
		return;

	assert(qu->state == query_tcpw);

	length[0] = (qu->query_dglen & 0x0ff00U) >> 8;
	length[1] = (qu->query_dglen & 0x0ff);

	ads = qu->ads;
	if( !adns__vbuf_ensure( &ads->tcpsend, ads->tcpsend.used + qu->query_dglen + 2 ) )
		return;

	qu->retries++;

	/* Reset idle timeout. */
	ads->tcptimeout.tv_sec = ads->tcptimeout.tv_usec = 0;

	if (ads->tcpsend.used) {
		wr = 0;
	} else {
#ifdef WIN32
		char *buf = NULL;
		
		buf = (char *)ns_malloc((2 + qu->query_dglen));
		os_memcpy(buf, length, 2);
		os_memcpy((buf + 2), qu->query_dgram, qu->query_dglen);
		wr = os_sock_write(qu->ads->tcpsocket, buf, (2 + qu->query_dglen));
		errno = os_sock_errno;
		ns_free(buf);
#else
		iov[0].iov_base = length;
		iov[0].iov_len = 2;
		iov[1].iov_base = qu->query_dgram;
		iov[1].iov_len = qu->query_dglen;
		adns__sigpipe_protect(qu->ads);
		wr = writev(qu->ads->tcpsocket, iov, 2);
#endif
		adns__sigpipe_unprotect(qu->ads);
		if (wr < 0) {
			if (!
			    (errno == EAGAIN || errno == OS_SOCK_EINTR
			     || errno == ENOSPC || errno == OS_SOCK_ENOBUFS
			     || errno == ENOMEM)) {
				adns__tcp_broken(ads, "write",
						 strerror(errno));
				return;
			}
			wr = 0;
		}
	}

	if( wr < 2 )
	{
		r = adns__vbuf_append( &ads->tcpsend, length, 2 - wr );
		assert( r );
		wr = 0;
	} 
	else 
	{
		wr -= 2;
	}
	if ( wr < qu->query_dglen ) 
	{
		r = adns__vbuf_append( &ads->tcpsend, qu->query_dgram + wr,
				      qu->query_dglen - wr );
		assert( r );
	}
}