ref: 64d062acdb9ed71cc251c69a08ee03e6c5bfcaaf
dir: /sys/src/libplumb/mesg.c/
#include <u.h>
#include <libc.h>
#include "plumb.h"
int
plumbopen(char *name, int omode)
{
int fd;
char buf[128], err[ERRMAX];
if(name[0] == '/')
return open(name, omode);
if(access("/mnt/plumb/send", AWRITE) < 0)
return -1;
snprint(buf, sizeof buf, "/mnt/plumb/%s", name);
fd = open(buf, omode);
if(fd >= 0)
return fd;
/* try creating port; used by non-standard plumb implementations */
rerrstr(err, sizeof err);
fd = create(buf, omode, 0600);
if(fd >= 0)
return fd;
errstr(err, sizeof err);
return -1;
}
static int
Strlen(char *s)
{
if(s == nil)
return 0;
return strlen(s);
}
static char*
Strcpy(char *s, char *t)
{
if(t == nil)
return s;
return strcpy(s, t) + strlen(t);
}
/* quote attribute value, if necessary */
static char*
quote(char *s, char *buf, char *bufe)
{
char *t;
int c;
if(s == nil){
buf[0] = '\0';
return buf;
}
if(strpbrk(s, " '=\t") == nil)
return s;
t = buf;
*t++ = '\'';
while(t < bufe-2){
c = *s++;
if(c == '\0')
break;
*t++ = c;
if(c == '\'')
*t++ = c;
}
*t++ = '\'';
*t = '\0';
return buf;
}
char*
plumbpackattr(Plumbattr *attr)
{
int n, l;
Plumbattr *a;
char *s, *t, *buf, *bufe;
if(attr == nil)
return nil;
n = 0;
for(a=attr; a!=nil; a=a->next){
l = Strlen(a->value);
if(l > n)
n = l;
}
if((buf = malloc(n*2+3)) == nil)
return nil;
bufe = buf + n*2+3;
n = 0;
for(a=attr; a!=nil; a=a->next)
n += Strlen(a->name) + 1 + Strlen(quote(a->value, buf, bufe)) + 1;
s = malloc(n);
if(s == nil){
free(buf);
return nil;
}
t = s;
*t = '\0';
for(a=attr; a!=nil; a=a->next){
if(t != s)
*t++ = ' ';
strcpy(t, a->name);
strcat(t, "=");
strcat(t, quote(a->value, buf, bufe));
t += strlen(t);
}
if(t > s+n)
abort();
free(buf);
return s;
}
char*
plumblookup(Plumbattr *attr, char *name)
{
while(attr){
if(strcmp(attr->name, name) == 0)
return attr->value;
attr = attr->next;
}
return nil;
}
char*
plumbpack(Plumbmsg *m, int *np)
{
int n, ndata;
char *buf, *p, *attr;
ndata = m->ndata;
if(ndata < 0)
ndata = Strlen(m->data);
attr = plumbpackattr(m->attr);
n = Strlen(m->src)+1 + Strlen(m->dst)+1 + Strlen(m->wdir)+1 +
Strlen(m->type)+1 + Strlen(attr)+1 + 16 + ndata;
buf = malloc(n+1); /* +1 for '\0' */
if(buf == nil){
free(attr);
return nil;
}
p = Strcpy(buf, m->src);
*p++ = '\n';
p = Strcpy(p, m->dst);
*p++ = '\n';
p = Strcpy(p, m->wdir);
*p++ = '\n';
p = Strcpy(p, m->type);
*p++ = '\n';
p = Strcpy(p, attr);
*p++ = '\n';
p += sprint(p, "%d\n", ndata);
memmove(p, m->data, ndata);
*np = (p-buf)+ndata;
buf[*np] = '\0'; /* null terminate just in case */
if(*np >= n+1)
abort();
free(attr);
return buf;
}
int
plumbsend(int fd, Plumbmsg *m)
{
char *buf;
int n;
buf = plumbpack(m, &n);
if(buf == nil)
return -1;
n = write(fd, buf, n);
free(buf);
return n;
}
void
plumbfree(Plumbmsg *m)
{
Plumbattr *a, *next;
free(m->src);
free(m->dst);
free(m->wdir);
free(m->type);
for(a=m->attr; a!=nil; a=next){
next = a->next;
free(a->name);
free(a->value);
free(a);
}
free(m->data);
free(m);
}
Plumbattr*
plumbunpackattr(char *p)
{
Plumbattr *attr, *prev, *a;
char *q, *v, *buf, *bufe;
int c, quoting;
c = strlen(p) + 1;
if((buf = malloc(c)) == nil)
return nil;
bufe = buf + c;
attr = prev = nil;
while(*p!='\0' && *p!='\n'){
while(*p==' ' || *p=='\t')
p++;
if(*p == '\0')
break;
for(q=p; *q!='\0' && *q!='\n' && *q!=' ' && *q!='\t'; q++)
if(*q == '=')
break;
if(*q != '=')
break; /* malformed attribute */
a = malloc(sizeof(Plumbattr));
if(a == nil)
break;
a->name = malloc(q-p+1);
if(a->name == nil){
free(a);
break;
}
memmove(a->name, p, q-p);
a->name[q-p] = '\0';
/* process quotes in value */
q++; /* skip '=' */
v = buf;
quoting = 0;
while(*q!='\0' && *q!='\n'){
if(v >= bufe)
break;
c = *q++;
if(quoting){
if(c == '\''){
if(*q == '\'')
q++;
else{
quoting = 0;
continue;
}
}
}else{
if(c==' ' || c=='\t')
break;
if(c == '\''){
quoting = 1;
continue;
}
}
*v++ = c;
}
a->value = malloc(v-buf+1);
if(a->value == nil){
free(a->name);
free(a);
break;
}
memmove(a->value, buf, v-buf);
a->value[v-buf] = '\0';
a->next = nil;
if(prev == nil)
attr = a;
else
prev->next = a;
prev = a;
p = q;
}
free(buf);
return attr;
}
Plumbattr*
plumbaddattr(Plumbattr *attr, Plumbattr *new)
{
Plumbattr *l;
l = attr;
if(l == nil)
return new;
while(l->next != nil)
l = l->next;
l->next = new;
return attr;
}
Plumbattr*
plumbdelattr(Plumbattr *attr, char *name)
{
Plumbattr *l, *prev;
prev = nil;
for(l=attr; l!=nil; l=l->next){
if(strcmp(name, l->name) == 0)
break;
prev = l;
}
if(l == nil)
return nil;
if(prev)
prev->next = l->next;
else
attr = l->next;
free(l->name);
free(l->value);
free(l);
return attr;
}
static char*
plumbline(char *buf, int *o, int n)
{
char *p;
int i;
i = *o;
if(i < 0 || i >= n)
return nil;
p = memchr(buf+i, '\n', n - i);
if(p == nil)
return nil;
n = p - (buf+i);
buf = malloc(n+1);
if(buf == nil)
return nil;
memmove(buf, p - n, n);
buf[n] = '\0';
*o = i + n+1;
return buf;
}
Plumbmsg*
plumbunpackpartial(char *buf, int n, int *morep)
{
Plumbmsg *m;
char *ntext, *attr;
int i;
if(morep != nil)
*morep = 0;
m = malloc(sizeof(Plumbmsg));
if(m == nil)
return nil;
setmalloctag(m, getcallerpc(&buf));
memset(m, 0, sizeof(Plumbmsg));
i = 0;
if((m->src = plumbline(buf, &i, n)) == nil)
goto bad;
if((m->dst = plumbline(buf, &i, n)) == nil)
goto bad;
if((m->wdir = plumbline(buf, &i, n)) == nil)
goto bad;
if((m->type = plumbline(buf, &i, n)) == nil)
goto bad;
if((attr = plumbline(buf, &i, n)) == nil)
goto bad;
m->attr = plumbunpackattr(attr);
free(attr);
if((ntext = plumbline(buf, &i, n)) == nil)
goto bad;
m->ndata = atoi(ntext);
free(ntext);
if(m->ndata < 0)
goto bad;
n -= i;
if(n < m->ndata){
if(morep != nil)
*morep = m->ndata - n;
goto bad;
}
m->data = malloc(m->ndata+1); /* +1 for '\0' */
if(m->data == nil)
goto bad;
memmove(m->data, buf+i, m->ndata);
/* null-terminate in case it's text */
m->data[m->ndata] = '\0';
return m;
bad:
plumbfree(m);
return nil;
}
Plumbmsg*
plumbunpack(char *buf, int n)
{
Plumbmsg *m;
m = plumbunpackpartial(buf, n, nil);
if(m != nil)
setmalloctag(m, getcallerpc(&buf));
return m;
}
Plumbmsg*
plumbrecv(int fd)
{
char *buf, *old;
Plumbmsg *m;
int n, more;
buf = malloc(n = 8192);
if(buf == nil)
return nil;
n = read(fd, buf, n);
if(n <= 0)
m = nil;
else {
m = plumbunpackpartial(buf, n, &more);
if(m == nil && more > 0){
/* we now know how many more bytes to read for complete message */
buf = realloc(old = buf, n+more);
if(buf == nil){
free(old);
return nil;
}
if(readn(fd, buf+n, more) == more)
m = plumbunpackpartial(buf, n+more, nil);
}
}
free(buf);
return m;
}