int Session::on_read_event()
{
int ret;
while (true)
{
if (!m_has_head)
{
ret = read_head();
if (ret < 0)
{
return -1;
}
if (ret == SESSION_RET_NO_DATA)
{
return 0;
}
if (m_msg_type == MSG_HEART_BEAT)
{
if (g_is_master)
{
update_active_time();
}
else
{
struct commu_msg msg;
msg.ip = get_cli_addr();
msg.msg = MSG_HEART_BEAT;
notify_master(msg);
}
continue;
}
m_has_head = true;
m_buff = (u_char *)glb_mempool()->get(m_msg_len);
}
int n_read = readn(m_sockfd, &m_buff[m_n_read], m_msg_len - m_n_read);
if (n_read < 0)
{
logerr("socket broken\n");
m_msg_len = 0;
m_has_head = false;
return -1;
}
m_n_read += n_read;
if (m_n_read == m_msg_len)
{
write_msg(m_buff, m_msg_len);
reset_buffer();
}
}
return 0;
}
/*
* on the server side of the negotiation protocol, we read
* the client response and then run the negotiated function.
* in some cases (e.g., TLS) the negotiated function needs to
* use v->datafd directly and be sure that no data has been
* buffered away in the Bio. since we know the client is waiting
* for our response, it won't have sent any until we respond.
* thus we read the response with vncrdstringx, which goes
* behind bio's back.
*/
char*
vncrdstringx(Vnc *v)
{
char tmp[4];
char *s;
ulong len;
assert(Bbuffered(&v->in) == 0);
if(readn(v->datafd, tmp, 4) != 4){
fprint(2, "cannot rdstringx: %r");
vnchungup(v);
}
len = LONG(tmp);
s = malloc(len+1);
assert(s != nil);
if(readn(v->datafd, s, len) != len){
fprint(2, "cannot rdstringx len %lud: %r", len);
vnchungup(v);
}
s[len] = '\0';
return s;
}
int priv_sock_get_int(int fd)
{
int the_int;
int ret;
ret = readn(fd, &the_int, sizeof(the_int));
if (ret != sizeof(the_int))
{
fprintf(stderr, "priv_sock_get_int error\n");
exit(EXIT_FAILURE);
}
return the_int;
}
int sckClient_rcv(void *handle, unsigned char *out, int *outlen)
{
int ret = 0;
SckHandle *tmp = handle;
ret = read_timeout(tmp->sockfd, tmp->recvtime);
if(ret < 0){
if(ret == -1 && errno == ETIMEDOUT){
ret = SCK_ERRTIMEOUT;
printf("sckClient_rcv() err: %d\n", ret);
return ret;
}
return ret;
}
int netdatalen = 0;
ret = readn(tmp->sockfd, &netdatalen, 4);
if(ret == -1 ){
printf("func sckClient_rcv() first err: %d\n", ret);
return ret;
}else if(ret < 4){
ret = SCK_ERRPEERCLOSED;
printf("func sckClient_rcv() first err: %d\n", ret);
return ret;
}
int n;
n = ntohl(netdatalen);
ret = readn(tmp->sockfd, out, n);
if(ret == -1 ){
printf("func sckClient_rcv() second err: %d\n", ret);
return ret;
}else if(ret < n){
ret = SCK_ERRPEERCLOSED;
printf("func sckClient_rcv() second err: %d\n", ret);
return ret;
}
*outlen = n;
return 0;
}
char priv_sock_get_result(int fd)
{
char res;
int ret;
ret = readn(fd, &res, sizeof(res));
if (ret != sizeof(res))
{
fprintf(stderr, "priv_sock_get_result error\n");
exit(EXIT_FAILURE);
}
return res;
}
static void
xread(Ioclust *c)
{
int n;
Xdata *dev;
dev = c->dev;
seek(dev->dev, (vlong)c->addr * Sectorsize, 0);
n = readn(dev->dev, c->iobuf, BUFPERCLUST*Sectorsize);
if(n < Sectorsize)
error("I/O read error");
c->nbuf = n/Sectorsize;
}
int usc_mrcp_asr_destroy(HANDLE_MRCPINTF asr)
{
char buf[48];
off_t offset = 0;
PUSH_FUN(buf, offset, sizeof(buf));
PUSH_HEAD(buf, offset, sizeof(buf));
writen(asr, buf, offset + 4);
/*read return value*/
readn(asr, buf, 8);
close(asr);
return 0;
}
char *
doread(Ram *r, int64_t off, int32_t cnt)
{
int n;
seek(tapefile, Tblock*r->addr + off, 0);
if (cnt > sizeof dblock.tbuf)
error("read too big");
n = readn(tapefile, dblock.tbuf, cnt);
if (n != cnt)
memset(dblock.tbuf + n, 0, cnt - n);
return dblock.tbuf;
}
ssize_t readline(int sockfd, void *buf, size_t maxline)
{
int ret;
int nread;
char *bufp = (char *)buf;
int nleft = maxline;
while(nleft > 0)
{
ret = recv_peek(sockfd, bufp, nleft);
if(ret < 0)
return ret;
else if(ret == 0)
return 0;
nread = ret;
int i;
for(i=0; i<nread; i++){
if(bufp[i] == '\n') {
ret = readn(sockfd, bufp, i + 1);
if( ret != i+1)
exit(-1);
return ret;
}
}
if(nread > nleft)
exit(-1);
nleft -= nread;
ret = readn(sockfd, bufp, nread);
if(ret != nread)
exit(-1);
bufp += nread;
}
return -1;
}
ssize_t readline(int fd, void *buf, size_t maxlen)
{
size_t nleft = maxlen - 1;
char *bufp = (char *)buf;
ssize_t total = 0;
ssize_t nread;
while (nleft > 0) {
//recv+peek为预读取
nread = recv_peek(fd, bufp, nleft);
if (nread <= 0)
return nread;
//检查此段内有无\n
int i;
for (i = 0; i < nread; ++i) {
if (bufp[i] == '\n') {
//找到\n后读取退出
size_t nsize = i + 1;
if (readn(fd, bufp, nsize) != nsize)
return -1;
bufp += nsize;
*bufp = '\0';
total += nsize;
return total;
}
}
//到此步说明没有找到\n，继续
if (readn(fd, bufp, nread) != nread)
return -1;
bufp += nread;
total += nread;
nleft -= nread;
}
//读取到最大长度，返回
*bufp = '\0';
return maxlen - 1;
}
ssize_t SocketIO::readline(char * buf, size_t maxlen)
{
size_t nleft = maxlen - 1;
char * pbuf = buf;
ssize_t nread;
size_t total = 0;
while(nleft > 0)
{
nread = recv_peek(pbuf, nleft);
if(nread <= 0)
return nread;
int i;
for(i = 0; i != nread; ++i)
{
//当找到'\n'
if(pbuf[i] == '\n')
{
size_t nsize = i + 1;
if(static_cast<ssize_t>(nsize)
!= readn(pbuf, nsize))
return -1;
pbuf += nsize;
total += nsize;
*pbuf = 0;
return total;
}
}
//当没有找到'\n'
if(readn(pbuf, nread) != nread)
return -1;
total += nread;
pbuf += nread;
nleft -= nread;
}
*pbuf = 0;
return maxlen - 1;
}
char *
readline (int fd)
{
char * line;
char * ptr;
int i = 0;
int nread = 0;
int len = 0;
int buflen = 0;
if ((line = (char *) malloc (LINE_BUF_SIZE * sizeof (char))) == NULL)
return NULL;
ptr = line;
/* we accept \r\n and \n as endline. */
while (len < (MAX_LINE_BUF_SIZE-1) && (nread = readn (fd, ptr, 1)) == 1
&& *ptr != '\n') {
if (*ptr != '\r') {
len += nread;
ptr += nread;
buflen += nread;
if (buflen == LINE_BUF_SIZE) {
i ++;
if ((line = realloc (line, (i+1) * LINE_BUF_SIZE * sizeof (char))) == NULL) {
free (line);
return NULL;
}
ptr = line + i * LINE_BUF_SIZE;
buflen = 0;
}
}
}
/* EOF */
if (len == 0 && nread == 0) {
free (line);
return NULL;
}
if (nread == -1 || len >= MAX_LINE_BUF_SIZE) {
free (line);
return NULL;
}
line [len] = 0;
return line;
}
int main (int argc, char *argv[]) {
double C = 60 * log(2);
double PI = 2 * acos(0);
fread_unlocked(s, sizeof(char), 10 * 1024 * 1024, stdin);
readn();
int i, t = n;
for (I = 0; I < t; I += 1) {
readn_signed();
a = n;
readn_signed();
b = n;
theta = atan2 (b, a) / PI;
r = log( (double)( a * a + b * b ) );
written = 1;
for (k = 1; k <= 4; k += 1) {
if ( k * r <= C && fabs ( k * theta - (int)(k * theta + 0.5) ) < 0.00001 ) {
writen(k);
written = 101;
break;
}
}
if ( written != 101 ) {
out[++wcount] = 'T';
out[++wcount] = 'O';
out[++wcount] = 'O';
out[++wcount] = ' ';
out[++wcount] = 'C';
out[++wcount] = 'O';
out[++wcount] = 'M';
out[++wcount] = 'P';
out[++wcount] = 'L';
out[++wcount] = 'I';
out[++wcount] = 'C';
out[++wcount] = 'A';
out[++wcount] = 'T';
out[++wcount] = 'E';
out[++wcount] = 'D';
}
out[++wcount] = '\n';
}
fwrite_unlocked(out, 1, wcount + 1, stdout);
return 0;
}
/* elf ----------------------------------------------------------------------*/
void
elf(int fd_s, int fd_d, Elf32_Word p_type, Elf32_Word p_flags,
Elf32_Addr* addr, int* size, int flag)
{
int i;
Elf32_Ehdr e_eh;
static Elf32_Phdr e_ph[32];
lseek(fd_s, 0, SEEK_SET); /* rewind */
readn(fd_s, &e_eh, sizeof(Elf32_Ehdr));
lseek(fd_s, e_eh.e_phoff, SEEK_SET);
readn(fd_s, (char*)e_ph, e_eh.e_phentsize * e_eh.e_phnum);
printf("#-----------------------------------------------------------------#\n");
printf("# [t]ype, [f]lag, [v]addr, [m]emsz, [s]filesz, [o]ffset #\n");
printf("# e_eh.e_phnum = %d\n", e_eh.e_phnum);
for (i = 0 ; i < e_eh.e_phnum ; i ++) {
printf("# ph[%d]: t = 0x%x, f = 0x%x, v = 0x%x, m = 0x%x, s = 0x%x o = %d\n",
i, e_ph[i].p_type, e_ph[i].p_flags, e_ph[i].p_vaddr, e_ph[i].p_memsz,
e_ph[i].p_filesz, e_ph[i].p_offset);
if (e_ph[i].p_type == p_type &&
e_ph[i].p_flags == p_flags) {
/* do everything ------------------------------------*/
if (flag) {
write_space(fd_d,
(int)(e_ph[i].p_vaddr - *addr) - *size);
}
lseek(fd_s, e_ph[i].p_offset, SEEK_SET);
readn(fd_s, buf, e_ph[i].p_filesz);
writen(fd_d, buf, e_ph[i].p_filesz);
*addr = e_ph[i].p_vaddr;
*size = e_ph[i].p_memsz;
printf("# virtual address = 0x%x, size = 0x%x\n", *addr, *size);
break;
}
}
}
int sckServer_rcv(int connfd, unsigned char *out, int *outlen, int timeout){
int ret = 0;
printf("sckServer_rcv() connfd=%d\n", connfd);
ret = read_timeout(connfd, timeout);
if(ret < 0){
if(ret == -1 && errno == ETIMEDOUT){
ret = SCK_ERRTIMEOUT;
printf("sckServer_rcv() read timeout err: %d\n", ret);
return ret;
}
return ret;
}
int netdatalen = 0;
ret = readn(connfd, &netdatalen, 4);
if(ret == -1 ){
printf("func sckServer_rcv() first err: %d\n", ret);
return ret;
}else if(ret < 4){
ret = SCK_ERRPEERCLOSED;
printf("func sckServer_rcv() first err: %d\n", ret);
return ret;
}
int n;
n = ntohl(netdatalen);
ret = readn(connfd, out, n);
if(ret == -1 ){
printf("func sckServer_rcv() second err: %d\n", ret);
return ret;
}else if(ret < n){
ret = SCK_ERRPEERCLOSED;
printf("func sckServer_rcv() second err: %d\n", ret);
return ret;
}
*outlen = n;
return 0;
}
static void
tcpreader(void *a)
{
Session *s = a;
uint8_t *buf;
int buflen = smbglobals.maxreceive + 4;
buf = nbemalloc(buflen);
for (;;) {
int n;
uint8_t flags;
uint16_t length;
n = readn(s->fd, buf, 4);
if (n != 4) {
die:
free(buf);
if (s->state == Connected)
(*s->write)(s, nil, -1);
deletesession(s);
return;
}
flags = buf[1];
length = nhgets(buf + 2) | ((flags & 1) << 16);
if (length > buflen - 4) {
print("nbss: too much data (%ud)\n", length);
goto die;
}
n = readn(s->fd, buf + 4, length);
if (n != length)
goto die;
if (s->state == Connected) {
if ((*s->write)(s, buf + 4, length) != 0) {
s->state = Dead;
goto die;
}
}
}
}
void ungz (int ifd, int ofd) {
uint8_t x[10];
switch (readn (ifd, x, 10)) {
case 0: return;
case 10: break;
default: errx (-1, "not in gz format");
}
if (x[0] != 0x1F || x[1] != 0x8B) errx (-1, "not in gz format");
if (x[2] != 8) errx (-1, "unknown z-algorithm: 0x%0hhX", x[2]);
if (x[3] & 1 << 2) /* FEXTRA */ {
uint16_t n;
uint8_t n_[2], _[1];
readn (ifd, n_, 2);
for (n = n_[0] << 0 | n_[1] << 8; n-- > 0; readn (ifd, _, 1));
}
if (x[3] & 1 << 3) /* FNAME */ skipString (ifd);
if (x[3] & 1 << 4) /* FCOMMENT */ skipString (ifd);
if (x[3] & 1 << 1) /* FCRC */ {
uint16_t _[1];
readn (ifd, _, 2);
}
go (0, ifd, ofd);
}
static uchar*
load(int fd, ulong off, int size)
{
uchar *a;
a = malloc(size);
if(a == nil)
return nil;
if(seek(fd, off, 0) < 0 || readn(fd, a, size) != size){
free(a);
return nil;
}
return a;
}
void do_service(int peerfd)
{
char recvbuf[1024];
int ret;
while(1)
{
memset(recvbuf, 0, sizeof recvbuf);
int data;
int len;
readn(peerfd, &data, sizeof data);
len = htonl(data);
ret = readn(peerfd, recvbuf, len);
if(ret == -1)
return;
else if(ret == 0)
break;
else
{
writen(peerfd, &data, sizeof data);
writen(peerfd, recvbuf,len);
}
}
}
static int
readblock(void *fd, DwarfBlock *b, ulong off, ulong len)
{
b->data = malloc(len);
if(b->data == nil)
return -1;
if(!seek(fd, off, 0) || !readn(fd, (char *)b->data, len)){
free(b->data);
b->data = nil;
return -1;
}
b->len = len;
return 0;
}
/*━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━*/
recvtext(int sd,char name[16],char len[20])
{
FILE *fp;
char recvbuf[1280];
int i,count,fsize;
fp=fopen(name,"w");
int l = atoi(len);
if(fp==NULL)return(-2);
count=l/1280;
fsize=l%1280;
for(i=0;i<count;i++)
{
readn(sd,recvbuf,1280);
fwrite(recvbuf,1,1280,fp);
}
if(fsize >0){
readn(sd,recvbuf,fsize);
fwrite(recvbuf,1,fsize,fp);
}
fclose(fp);
return 0;
}
/* Function invoked for sub-station (i.e., child process of the main server process) */
int sub_station() {
int tcp_sock, sub_sock, s;
in_port_t self_port;
struct sockaddr_in sub_self, curr_client;
Message from_msg, to_msg;
self_port = getpid();
printf("[Initiating sub-station %d]\n", self_port);
memset((char*)&sub_self, 0, sizeof(struct sockaddr_in));
memset((char*)&curr_client, 0, sizeof(struct sockaddr_in));
sub_self.sin_family = AF_INET;
sub_self.sin_port = htons(self_port);
sub_self.sin_addr.s_addr = inet_addr(LOOPBACK_ADDR);
// Let the main station(parent process) transmit the necessary infos to the client first
//sleep(2);
if((tcp_sock=socket(AF_INET, SOCK_STREAM, 0)) == -1)
goto err_ret;
if(bind(tcp_sock, (struct sockaddr*)&sub_self, sizeof(sub_self)) == -1)
goto err_ret;
if(listen(tcp_sock, 1) == -1)
goto err_ret;
s = sizeof(curr_client);
if((sub_sock=accept(tcp_sock, (struct sockaddr*)&curr_client, &s)) == -1)
goto err_ret;
printf("[Sub-station %d]: Connection with host %d was successful\n", htons(self_port), htons(curr_client.sin_port));
// Start communication with the host('A' or 'B')
printf("[Begin communication]\n");
while(1) {
// readn(sub_sock, (Message*)&from_msg, sizeof(Message));
readn(sub_sock, (char*)&from_msg, sizeof(Message));
if(from_msg.header.type == MSG_DELIVER) { //Deliver mesg to host B
msg_deliver(&from_msg);
} else { // Else consider illegal message
msg_reject(&curr_client);
}
}
close(sub_sock);
close(tcp_sock);
err_ret:
fprintf(stderr, "[ERROR: Sub-station failure]\n");
return EXIT_FAILURE;
}
//: MSG_MA
int interface_manage_permision(int pSockFD, I_REQUEST_H *header)
{
int ret = M_TRUE ;
int rlen, wlen ;
I_MP_IN in ;
I_RESULT_H i_result_h ;
fd_set readset ;
struct timeval tmv ;
FD_ZERO(&readset) ;
FD_SET(pSockFD, &readset) ;
tmv.tv_sec = 30 ; tmv.tv_usec = 0 ;
if(select(pSockFD+1, &readset, NULL, NULL, &tmv) < 0) {
printLog(HEAD, "ERR: (%.18s)select Error : SOCKET(%d) CLOSE\n",
header->productid, pSockFD) ;
return M_FAIL ;
}
if (!FD_ISSET(pSockFD, &readset)) { // 30초동안 msgid를 받지 못한 경우,
printLog(HEAD, "ERR: (%.18s)SockFD(%d) TimeOut wait read_time(%d)\n",
header->productid, pSockFD, tmv.tv_sec) ;
return M_FAIL ;
}
memset(&in, 0, sizeof(I_MP_IN)) ;
if((rlen = readn(pSockFD, &in, sizeof(I_MP_IN))) != sizeof(I_MP_IN)) {
printLog(HEAD, "ERR: (%.18s)Socket Read Fail(%d/%d)\n", header->productid, rlen, sizeof(I_MP_IN));
return M_FAIL ;
}
in.flag = ntohl(in.flag) ;
printLog(HEAD, "READ: (LEN:%d) (%.18s) I_MP_IN-FLAG[%d]\n", rlen, header->productid, in.flag) ;
ret = db_manage_permision(header, &in) ;
printLog(HEAD, "(%.18s) db_manage_permision() RET(%d)\n", header->productid, ret) ;
i_result_h.error = htonl(ret) ;
i_result_h.count = htonl(0) ;
i_result_h.total = htonl(0) ;
if((wlen = writen(pSockFD, &i_result_h, sizeof(I_RESULT_H))) != sizeof(I_RESULT_H)) {
printLog(HEAD, "ERR: (%.18s)Socket write Fail(%d/%d)\n", header->productid, wlen, sizeof(I_RESULT_H)) ;
return M_FAIL ;
}
printLog(HEAD, "SEND: (LEN:%d) (%.18s) I_RESULT_H-ERRCODE(%d) COUNT(%d) TOTAL(%d)\n",
wlen, header->productid, ntohl(i_result_h.error), ntohl(i_result_h.count), ntohl(i_result_h.total)) ;
return ret ;
}
void
watcher(void)
{
Json *jv, *jtop;
vlong id;
char *text, *created_at, *user;
char *buf;
int fd, n, i;
char fname[64];
buf = malloc(BUFSIZ);
if(buf == nil)
sysfatal("malloc: %r");
for(;;){
fetch(fname);
fd = open(fname, OREAD);
n = readn(fd, buf, BUFSIZ);
if(n <= 0){
fprint(2, "read failed.\n");
sleep(INTERVAL);
continue;
}
/*print("(read %d bytes in %s)\n", n, fname);*/
buf[n] = 0;
jtop = parsejson(buf);
if(jtop == nil){
fprint(2, "parsejson failed.\n");
sleep(INTERVAL);
continue;
}
jv = jtop->value[0]; /* FIXME */
for(i = jv->len - 1; i >= 0; i--){
id = jint(jlookup(jv->value[i], "id"));
if(id <= lastid)
continue;
text = jstring(jlookup(jv->value[i], "text"));
created_at = jstring(jlookup(jv->value[i], "created_at"));
user = jstring(jlookup(jv->value[i], "from_user"));
print("[%s] %s (%s)\n", user, text, created_at);
lastid = id;
}
jclose(jv);
close(fd);
sleep(INTERVAL);
}
}
const int SerialImpl::readWithControl(const int fd, char *buf, const int size)
{
char tmp[256];
int iTotSize = size + 2; // start(byte) + data(size) + end(byte)
if (iTotSize != readn (fd, tmp, iTotSize)) {
return (kuNOK);
}
// copies received data to user buffer
memcpy (buf, tmp + 1, size);
return (size);
}
int main(void){
while(scanf("%d",&n)!=EOF){
first = 1, sign = '+';
if(n<0) sign = '-',n/=-1;
if(n) doprint(8);
for(i = 0; i < 8; i++){
readn(&n);
if(n) doprint(7-i);
}
if(first) putchar('0');
putchar('\n');
}
return 0;
}
Packet *recvPkt(int sd) {
Packet *pkt = NULL;
pkt = (Packet*)calloc(1, sizeof(Packet));
if(!pkt) {
fprintf(stderr, "Can't calloc.\n");
return NULL;
}
if(!readn(sd, (char*)&pkt->type, sizeof(pkt->type))) {
free(pkt);
return NULL;
}
if(!readn(sd, (char*)&pkt->len, sizeof(pkt->len))) {
free(pkt);
return NULL;
}
pkt->len = ntohl(pkt->len);
if(pkt->len > 0) {
pkt->text = (char*)malloc(pkt->len);
if(!pkt->text) {
fprintf(stderr, "Can't malloc.\n");
free(pkt);
return NULL;
}
if(!readn(sd, pkt->text, pkt->len)) {
free(pkt);
return NULL;
}
}
//printf("recvPkt: type %d len %d text %s\n", pkt->type, pkt->len, pkt->text);
return pkt;
}
/* Function to run thread that receives packets from the tunnel,
strips off the header, and sends the to the tap. sockets should
be a pointer to a socks_h structure holding the socket
file descriptors. */
void* incoming(void* sockets) {
char msg[PAYLOAD_SIZE];
ushort type, msg_length;
int sent, sent_total;
struct socks_h *socks = (struct socks_h*)sockets;
while(1) { // Loop forever
// Get next header
readn(socks->remote_sock, msg, HEADER_SIZE);
// Get packet type and length
type = ntohs(*(ushort*)msg);
msg_length = ntohs(*(ushort*)(msg+TYPE_SIZE));
printf("Received header from tunnel: type %x\tlength: %u \n", type, msg_length);
// Get packet payload
readn(socks->remote_sock, msg, msg_length);
// Send payload to tap
sent_total = 0;
do { // Keep sending until entire payload has been sent
if((sent = write(socks->tun_sock, msg+sent_total, msg_length - sent_total)) < 0) {
perror("Incoming send");
exit(EXIT_FAILURE);
}
sent_total += sent;
} while(sent_total < msg_length);
printf("Sent %d bytes to tap\n", sent_total);
}
printf("Exiting outgoing thread\n");
return NULL;
}
int
main(int argc, char **argv)
{
int sd;
int n;
int toread;
char writebuf[8192];
char readbuf[1024 * 1024];
char *str;
sd = connect_to_server(DEFAULT_IPADDR, DEFAULT_PORT);
assert(sd >= 0);
str = "cas foo 0 0 3 1\r\nbar\r\n";
printf("write: %4d: %s", strlen(str), str);
n = write(sd, str, strlen(str));
if (n < 0) {
perror("write");
}
assert(n == strlen(str));
n = read(sd, readbuf, 1);
if (n < 0) {
perror("read");
}
assert(n == 1);
printf("read : %4d: %.*s", n, n, readbuf);
if (readbuf[0] == 'S') {
toread = strlen("STORED") + strlen("\r\n") - 1;
} else if (readbuf[0] == 'E') {
toread = strlen("EXISTS") + strlen("\r\n") - 1;
} else if (readbuf[0] == 'N') {
toread = strlen("NOT_FOUND") + strlen("\r\n") - 1;
} else {
assert(0);
}
n = readn(sd, readbuf, toread);
if (n < 0) {
perror("read");
}
assert(n > 0);
printf("%.*s", n, readbuf);
close(sd);
return 0;
}
void
threadmain(int argc, char *argv[])
{
char *host;
int dotrunc, n, type;
uchar *p, score[VtScoreSize];
VtConn *z;
fmtinstall('F', vtfcallfmt);
fmtinstall('V', vtscorefmt);
host = nil;
dotrunc = 0;
type = VtDataType;
ARGBEGIN{
case 'z':
dotrunc = 1;
break;
case 'h':
host = EARGF(usage());
break;
case 't':
type = atoi(EARGF(usage()));
break;
default:
usage();
break;
}ARGEND
if(argc != 0)
usage();
p = vtmallocz(VtMaxLumpSize+1);
n = readn(0, p, VtMaxLumpSize+1);
if(n > VtMaxLumpSize)
sysfatal("input too big: max block size is %d", VtMaxLumpSize);
z = vtdial(host);
if(z == nil)
sysfatal("could not connect to server: %r");
if(vtconnect(z) < 0)
sysfatal("vtconnect: %r");
if(dotrunc)
n = vtzerotruncate(type, p, n);
if(vtwrite(z, score, type, p, n) < 0)
sysfatal("vtwrite: %r");
vthangup(z);
print("%V\n", score);
threadexitsall(0);
}
