<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"

<?xml version="1.0" encoding="utf-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv=Content-Type content="text/html; charset=utf8">
<title>/usr/web/sources/contrib/cinap_lenrek/nntpfs.c - Plan 9 from Bell Labs</title>


</meta>
</head>
<body>


<a href="/plan9/">Plan 9 from Bell Labs</a>’s /usr/web/sources/contrib/cinap_lenrek/nntpfs.c


<center>
Copyright © 2009 Alcatel-Lucent. 
Distributed under the
<a href="/plan9/license.html">Lucent Public License version 1.02</a>.
 
<a href="/plan9/download.html">Download the Plan 9 distribution.</a>

</center>

<table width="100%" cellspacing=0 border=0><tr><td align="center">
<table cellspacing=0 cellpadding=5 bgcolor="#eeeeff"><tr><td align="left">
<pre>

/*
* Network news transport protocol (NNTP) file server.
*
* Unfortunately, the file system differs from that expected
* by Charles Forsyth's rin news reader. This is partially out
* of my own laziness, but it makes the bookkeeping here
* a lot easier.
*/

#include <u.h>
#include <libc.h>
#include <bio.h>
#include <auth.h>
#include <fcall.h>
#include <thread.h>
#include <9p.h>

typedef struct Netbuf Netbuf;
typedef struct Group Group;

struct Netbuf {
Biobuf br;
Biobuf bw;
int lineno;
int fd;
int code; /* last response code */
int auth; /* Authorization required? */
char response[128]; /* last response */
Group *currentgroup;
char *addr;
char *user;
char *pass;
ulong extended; /* supported extensions */
};

struct Group {
char *name;
Group *parent;
Group **kid;
int num;
int nkid;
int lo, hi;
int canpost;
int isgroup; /* might just be piece of hierarchy */
ulong mtime;
ulong atime;
};

/*
* First eight fields are, in order:
* article number, subject, author, date, message-ID,
* references, byte count, line count
* We don't support OVERVIEW.FMT; when I see a server with more
* interesting fields, I'll implement support then. In the meantime,
* the standard defines the first eight fields.
*/

/* Extensions */
enum {
Nxover = (1<<0),
Nxhdr = (1<<1),
Nxpat = (1<<2),
Nxlistgp = (1<<3),
};

Group *root;
Netbuf *net;
ulong now;
int netdebug;
int readonly;

void*
erealloc(void *v, ulong n)
{
v = realloc(v, n);
if(v == nil)
sysfatal("out of memory reallocating %lud", n);
setmalloctag(v, getcallerpc(&v));
return v;
}

void*
emalloc(ulong n)
{
void *v;

v = malloc(n);
if(v == nil)
sysfatal("out of memory allocating %lud", n);
memset(v, 0, n);
setmalloctag(v, getcallerpc(&n));
return v;
}

char*
estrdup(char *s)
{
int l;
char *t;

if (s == nil)
return nil;
l = strlen(s)+1;
t = emalloc(l);
memcpy(t, s, l);
setmalloctag(t, getcallerpc(&s));
return t;
}

char*
estrdupn(char *s, int n)
{
int l;
char *t;

l = strlen(s);
if(l > n)
l = n;
t = emalloc(l+1);
memmove(t, s, l);
t[l] = '\0';
setmalloctag(t, getcallerpc(&s));
return t;
}

static char base64[] =
"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

char*
decode64(char *s)
{
int state;

char c;
char *d;
char *dst;

dst = d = malloc(strlen(s)+1);

state = 0;

while(c = *s++){
char *p;

if(strchr("\n\r ", c))
continue;
if(c == '=')
break;

if((p = strchr(base64, c)) == 0)
goto errout;

switch(state){
case 0:
d[0] = ((p - base64) << 2);
state = 1;
break;
case 1:
d[0] |= ((p - base64) >> 4);
d[1] = (((p - base64) & 0x0f) << 4);
d++;
state = 2;
break;
case 2:
d[0] |= ((p - base64) >> 2);
d[1] = (((p - base64) & 0x03) << 6);
d++;
state = 3;
break;
case 3:
d[0] |= (p - base64);
d++;
state = 0;
break;
}
}
*++d = 0;
return dst;

errout:
free(dst);
return nil;
}

void
convertarticle(char *data)
{
char *s;
int isb64;

s = data;
isb64 = 0;
while(*s){
if(*s == '\n')
break;
if(strstr(s, "Content-Transfer-Encoding: base64") == s)
isb64 = 1;
while(*s && *s != '\n')
s++;
if(*s)
s++;
}
if(*s++ == '\n' && isb64){
char *x;
if(x = decode64(s)){
strcpy(s, x);
free(x);
}
}
}

char*
Nrdline(Netbuf *n)
{
char *p;
int l;

n->lineno++;
Bflush(&n->bw);
if((p = Brdline(&n->br, '\n')) == nil){
werrstr("nntp eof");
return nil;
}
p[l=Blinelen(&n->br)-1] = '\0';
if(l > 0 && p[l-1] == '\r')
p[l-1] = '\0';
if(netdebug)
fprint(2, "-> %s\n", p);
return p;
}

int
nntpresponse(Netbuf *n, int e, char *cmd)
{
int r;
char *p;

for(;;){
p = Nrdline(n);
if(p==nil){
strcpy(n->response, "early nntp eof");
return -1;
}
r = atoi(p);
if(r/100 == 1){ /* BUG? */
fprint(2, "%s\n", p);
continue;
}
break;
}

strecpy(n->response, n->response+sizeof(n->response), p);

if((r=atoi(p)) == 0){
close(n->fd);
n->fd = -1;
fprint(2, "bad nntp response: %s\n", p);
werrstr("bad nntp response");
return -1;
}

n->code = r;
if(0 < e && e<10 && r/100 != e){
fprint(2, "%s: expected %dxx: got %s\n", cmd, e, n->response);
return -1;
}
if(10 <= e && e<100 && r/10 != e){
fprint(2, "%s: expected %dx: got %s\n", cmd, e, n->response);
return -1;
}
if(100 <= e && r != e){
fprint(2, "%s: expected %d: got %s\n", cmd, e, n->response);
return -1;
}
return r;
}

int nntpauth(Netbuf*);
int nntpxcmdprobe(Netbuf*);
int nntpcurrentgroup(Netbuf*, Group*);

/* XXX: bug OVER/XOVER et al. */
static struct {
ulong n;
char *s;
} extensions [] = {
{ Nxover, "OVER" },
{ Nxhdr, "HDR" },
{ Nxpat, "PAT" },
{ Nxlistgp, "LISTGROUP" },
{ 0, nil }
};

static int indial;

int
nntpconnect(Netbuf *n)
{
n->currentgroup = nil;
close(n->fd);
if((n->fd = dial(n->addr, nil, nil, nil)) < 0){
snprint(n->response, sizeof n->response, "dial: %r");
return -1;
}
Binit(&n->br, n->fd, OREAD);
Binit(&n->bw, n->fd, OWRITE);
if(nntpresponse(n, 20, "greeting") < 0)
return -1;
readonly = (n->code == 201);

indial = 1;
if(n->auth != 0)
nntpauth(n);
// nntpxcmdprobe(n);
indial = 0;
return 0;
}

int
nntpcmd(Netbuf *n, char *cmd, int e)
{
int tried;

tried = 0;
for(;;){
if(netdebug)
fprint(2, "<- %s\n", cmd);
Bprint(&n->bw, "%s\r\n", cmd);
if(nntpresponse(n, e, cmd)>=0 && (e < 0 || n->code/100 != 5))
return 0;

/* redial */
if(indial || tried++ || nntpconnect(n) < 0)
return -1;
}
}

int
nntpauth(Netbuf *n)
{
char cmd[256];

snprint(cmd, sizeof cmd, "AUTHINFO USER %s", n->user);
if (nntpcmd(n, cmd, -1) < 0 || n->code != 381) {
fprint(2, "Authentication failed: %s\n", n->response);
return -1;
}

snprint(cmd, sizeof cmd, "AUTHINFO PASS %s", n->pass);
if (nntpcmd(n, cmd, -1) < 0 || n->code != 281) {
fprint(2, "Authentication failed: %s\n", n->response);
return -1;
}

return 0;
}

int
nntpxcmdprobe(Netbuf *n)
{
int i;
char *p;

n->extended = 0;
if (nntpcmd(n, "LIST EXTENSIONS", 0) < 0 || n->code != 202)
return 0;

while((p = Nrdline(n)) != nil) {
if (strcmp(p, ".") == 0)
break;

for(i=0; extensions[i].s != nil; i++)
if (cistrcmp(extensions[i].s, p) == 0) {
n->extended |= extensions[i].n;
break;
}
}
return 0;
}

/* XXX: searching, lazy evaluation */
static int
overcmp(void *v1, void *v2)
{
int a, b;

a = atoi(*(char**)v1);
b = atoi(*(char**)v2);

if(a < b)
return -1;
else if(a > b)
return 1;
return 0;
}

enum {
XoverChunk = 100,
};

char *xover[XoverChunk];
int xoverlo;
int xoverhi;
int xovercount;
Group *xovergroup;

char*
nntpover(Netbuf *n, Group *g, int m)
{
int i, lo, hi, mid, msg;
char *p;
char cmd[64];

if (g->isgroup == 0) /* BUG: should check extension capabilities */
return nil;

if(g != xovergroup || m < xoverlo || m >= xoverhi){
lo = (m/XoverChunk)*XoverChunk;
hi = lo+XoverChunk;

if(lo < g->lo)
lo = g->lo;
else if (lo > g->hi)
lo = g->hi;
if(hi < lo || hi > g->hi)
hi = g->hi;

if(nntpcurrentgroup(n, g) < 0)
return nil;

if(lo == hi)
snprint(cmd, sizeof cmd, "XOVER %d", hi);
else
snprint(cmd, sizeof cmd, "XOVER %d-%d", lo, hi-1);
if(nntpcmd(n, cmd, 224) < 0)
return nil;

for(i=0; (p = Nrdline(n)) != nil; i++) {
if(strcmp(p, ".") == 0)
break;
if(i >= XoverChunk)
sysfatal("news server doesn't play by the rules");
free(xover[i]);
xover[i] = emalloc(strlen(p)+2);
strcpy(xover[i], p);
strcat(xover[i], "\n");
}
qsort(xover, i, sizeof(xover[0]), overcmp);

xovercount = i;

xovergroup = g;
xoverlo = lo;
xoverhi = hi;
}

lo = 0;
hi = xovercount;
/* search for message */
while(lo < hi){
mid = (lo+hi)/2;
msg = atoi(xover[mid]);
if(m == msg)
return xover[mid];
else if(m < msg)
hi = mid;
else
lo = mid+1;
}
return nil;
}

/*
* Return the new Group structure for the group name.
* Destroys name.
*/
static int printgroup(char*,Group*);
Group*
findgroup(Group *g, char *name, int mk)
{
int lo, hi, m;
char *p, *q;
static int ngroup;

for(p=name; *p; p=q){
if(q = strchr(p, '.'))
*q++ = '\0';
else
q = p+strlen(p);

lo = 0;
hi = g->nkid;
while(hi-lo > 1){
m = (lo+hi)/2;
if(strcmp(p, g->kid[m]->name) < 0)
hi = m;
else
lo = m;
}
assert(lo==hi || lo==hi-1);
if(lo==hi || strcmp(p, g->kid[lo]->name) != 0){
if(mk==0)
return nil;
if(g->nkid%16 == 0)
g->kid = erealloc(g->kid, (g->nkid+16)*sizeof(g->kid[0]));

/*
* if we're down to a single place 'twixt lo and hi, the insertion might need
* to go at lo or at hi. strcmp to find out. the list needs to stay sorted.
*/
if(lo==hi-1 && strcmp(p, g->kid[lo]->name) < 0)
hi = lo;

if(hi < g->nkid)
memmove(g->kid+hi+1, g->kid+hi, sizeof(g->kid[0])*(g->nkid-hi));
g->nkid++;
g->kid[hi] = emalloc(sizeof(*g));
g->kid[hi]->parent = g;
g = g->kid[hi];
g->name = estrdup(p);
g->num = ++ngroup;
g->mtime = time(0);
}else
g = g->kid[lo];
}
if(mk)
g->isgroup = 1;
return g;
}

static int
printgroup(char *s, Group *g)
{
if(g->parent == g)
return 0;

if(printgroup(s, g->parent))
strcat(s, ".");
strcat(s, g->name);
return 1;
}

static char*
Nreaddata(Netbuf *n)
{
char *p, *q;
int l;

p = nil;
l = 0;
for(;;){
q = Nrdline(n);
if(q==nil){
free(p);
return nil;
}
if(strcmp(q, ".")==0)
return p;
if(q[0]=='.')
q++;
p = erealloc(p, l+strlen(q)+1+1);
strcpy(p+l, q);
strcat(p+l, "\n");
l += strlen(p+l);
}
}

/*
* Return the output of a HEAD, BODY, or ARTICLE command.
*/
char*
nntpget(Netbuf *n, Group *g, int msg, char *retr)
{
char *s;
char cmd[1024];

if(g->isgroup == 0){
werrstr("not a group");
return nil;
}

if(strcmp(retr, "XOVER") == 0){
s = nntpover(n, g, msg);
if(s == nil)
s = "";
return estrdup(s);
}

if(nntpcurrentgroup(n, g) < 0)
return nil;
sprint(cmd, "%s %d", retr, msg);
nntpcmd(n, cmd, 0);
if(n->code/10 != 22)
return nil;

s = Nreaddata(n);
if(strcmp(retr, "ARTICLE") == 0)
convertarticle(s);

return s;
}

int
nntpcurrentgroup(Netbuf *n, Group *g)
{
char cmd[1024];

if(n->currentgroup != g){
strcpy(cmd, "GROUP ");
printgroup(cmd, g);
if(nntpcmd(n, cmd, 21) < 0)
return -1;
n->currentgroup = g;
}
return 0;
}

void
nntprefreshall(Netbuf *n)
{
char *f[10], *p;
int hi, lo, nf;
Group *g;

if(nntpcmd(n, "LIST", 21) < 0)
return;

while(p = Nrdline(n)){
if(strcmp(p, ".")==0)
break;

nf = getfields(p, f, nelem(f), 1, "\t\r\n ");
if(nf != 4){
int i;
for(i=0; i<nf; i++)
fprint(2, "%s%s", i?" ":"", f[i]);
fprint(2, "\n");
fprint(2, "syntax error in group list, line %d", n->lineno);
return;
}
g = findgroup(root, f[0], 1);
hi = strtol(f[1], 0, 10)+1;
lo = strtol(f[2], 0, 10);
if(g->hi != hi){
g->hi = hi;
if(g->lo==0)
g->lo = lo;
g->canpost = f[3][0] == 'y';
g->mtime = time(0);
}
}
}

void
nntprefresh(Netbuf *n, Group *g)
{
char cmd[1024];
char *f[5];
int lo, hi;

if(g->isgroup==0)
return;

if(time(0) - g->atime < 30)
return;

strcpy(cmd, "GROUP ");
printgroup(cmd, g);
if(nntpcmd(n, cmd, 21) < 0){
n->currentgroup = nil;
return;
}
n->currentgroup = g;

if(tokenize(n->response, f, nelem(f)) < 4){
fprint(2, "error reading GROUP response");
return;
}

/* backwards from LIST! */
hi = strtol(f[3], 0, 10)+1;
lo = strtol(f[2], 0, 10);
if(g->hi != hi){
g->mtime = time(0);
if(g->lo==0)
g->lo = lo;
g->hi = hi;
}
g->atime = time(0);
}

char*
nntppost(Netbuf *n, char *msg)
{
char *p, *q;

if(nntpcmd(n, "POST", 34) < 0)
return n->response;

for(p=msg; *p; p=q){
if(q = strchr(p, '\n'))
*q++ = '\0';
else
q = p+strlen(p);

if(p[0]=='.')
Bputc(&n->bw, '.');
Bwrite(&n->bw, p, strlen(p));
Bputc(&n->bw, '\r');
Bputc(&n->bw, '\n');
}
Bprint(&n->bw, ".\r\n");

if(nntpresponse(n, 0, nil) < 0)
return n->response;

if(n->code/100 != 2)
return n->response;
return nil;
}

/*
* Because an expanded QID space makes thngs much easier,
* we sleazily use the version part of the QID as more path bits.
* Since we make sure not to mount ourselves cached, this
* doesn't break anything (unless you want to bind on top of
* things in this file system). In the next version of 9P, we'll
* have more QID bits to play with.
*
* The newsgroup is encoded in the top 15 bits
* of the path. The message number is the bottom 17 bits.
* The file within the message directory is in the version [sic].
*/

enum { /* file qids */
Qhead,
Qbody,
Qarticle,
Qxover,
Nfile,
};
char *filename[] = {
"header",
"body",
"article",
"xover",
};
char *nntpname[] = {
"HEAD",
"BODY",
"ARTICLE",
"XOVER",
};

#define GROUP(p) (((p)>>17)&0x3FFF)
#define MESSAGE(p) ((p)&0x1FFFF)
#define FILE(v) ((v)&0x3)

#define PATH(g,m) ((((g)&0x3FFF)<<17)|((m)&0x1FFFF))
#define POST(g) PATH(0,g,0)
#define VERS(f) ((f)&0x3)

typedef struct Aux Aux;
struct Aux {
Group *g;
int n;
int ispost;
int file;
char *s;
int ns;
int offset;
};

static void
fsattach(Req *r)
{
Aux *a;
char *spec;

spec = r->ifcall.aname;
if(spec && spec[0]){
respond(r, "invalid attach specifier");
return;
}

a = emalloc(sizeof *a);
a->g = root;
a->n = -1;
r->fid->aux = a;

r->ofcall.qid = (Qid){0, 0, QTDIR};
r->fid->qid = r->ofcall.qid;
respond(r, nil);
}

static char*
fsclone(Fid *ofid, Fid *fid)
{
Aux *a;

a = emalloc(sizeof(*a));
*a = *(Aux*)ofid->aux;
fid->aux = a;
return nil;
}

static char*
fswalk1(Fid *fid, char *name, Qid *qid)
{
char *p;
int i, isdotdot, n;
Aux *a;
Group *ng;

isdotdot = strcmp(name, "..")==0;

a = fid->aux;
if(a->s) /* file */
return "protocol botch";
if(a->n != -1){
if(isdotdot){
*qid = (Qid){PATH(a->g->num, 0), 0, QTDIR};
fid->qid = *qid;
a->n = -1;
return nil;
}
for(i=0; i<Nfile; i++){
if(strcmp(name, filename[i])==0){
if(a->s = nntpget(net, a->g, a->n, nntpname[i])){
if(i == Qbody){
char *x;

if(x = nntpget(net, a->g, a->n, nntpname[Qhead])){
if(strstr(x, "Content-Transfer-Encoding: base64")){
char *t;
if(t = decode64(a->s)){
free(a->s);
a->s = t;
}
}
free(x);
}
}

*qid = (Qid){PATH(a->g->num, a->n), Qbody, 0};
fid->qid = *qid;
a->file = i;
return nil;
}else
return "file does not exist";
}
}
return "file does not exist";
}

if(isdotdot){
a->g = a->g->parent;
*qid = (Qid){PATH(a->g->num, 0), 0, QTDIR};
fid->qid = *qid;
return nil;
}

if(a->g->isgroup && !readonly && a->g->canpost
&& strcmp(name, "post")==0){
a->ispost = 1;
*qid = (Qid){PATH(a->g->num, 0), 0, 0};
fid->qid = *qid;
return nil;
}

if(ng = findgroup(a->g, name, 0)){
a->g = ng;
*qid = (Qid){PATH(a->g->num, 0), 0, QTDIR};
fid->qid = *qid;
return nil;
}

n = strtoul(name, &p, 0);
if('0'<=name[0] && name[0]<='9' && *p=='\0' && a->g->lo<=n && n<a->g->hi){
a->n = n;
*qid = (Qid){PATH(a->g->num, n+1-a->g->lo), 0, QTDIR};
fid->qid = *qid;
return nil;
}

return "file does not exist";
}

static void
fsopen(Req *r)
{
Aux *a;

a = r->fid->aux;
if((a->ispost && (r->ifcall.mode&~OTRUNC) != OWRITE)
|| (!a->ispost && r->ifcall.mode != OREAD))
respond(r, "permission denied");
else
respond(r, nil);
}

static void
fillstat(Dir *d, Aux *a)
{
char buf[32];
Group *g;

memset(d, 0, sizeof *d);
d->uid = estrdup("nntp");
d->gid = estrdup("nntp");
g = a->g;
d->atime = d->mtime = g->mtime;

if(a->ispost){
d->name = estrdup("post");
d->mode = 0222;
d->qid = (Qid){PATH(g->num, 0), 0, 0};
d->length = a->ns;
return;
}

if(a->s){ /* article file */
d->name = estrdup(filename[a->file]);
d->mode = 0444;
d->qid = (Qid){PATH(g->num, a->n+1-g->lo), a->file, 0};
return;
}

if(a->n != -1){ /* article directory */
sprint(buf, "%d", a->n);
d->name = estrdup(buf);
d->mode = DMDIR|0555;
d->qid = (Qid){PATH(g->num, a->n+1-g->lo), 0, QTDIR};
return;
}

/* group directory */
if(g->name[0])
d->name = estrdup(g->name);
else
d->name = estrdup("/");
d->mode = DMDIR|0555;
d->qid = (Qid){PATH(g->num, 0), g->hi-1, QTDIR};
}

static int
dirfillstat(Dir *d, Aux *a, int i)
{
int ndir;
Group *g;
char buf[32];

memset(d, 0, sizeof *d);
d->uid = estrdup("nntp");
d->gid = estrdup("nntp");

g = a->g;
d->atime = d->mtime = g->mtime;

if(a->n != -1){ /* article directory */
if(i >= Nfile)
return -1;

d->name = estrdup(filename[i]);
d->mode = 0444;
d->qid = (Qid){PATH(g->num, a->n), i, 0};
return 0;
}

/* hierarchy directory: child groups */
if(i < g->nkid){
d->name = estrdup(g->kid[i]->name);
d->mode = DMDIR|0555;
d->qid = (Qid){PATH(g->kid[i]->num, 0), g->kid[i]->hi-1, QTDIR};
return 0;
}
i -= g->nkid;

/* group directory: post file */
if(g->isgroup && !readonly && g->canpost){
if(i < 1){
d->name = estrdup("post");
d->mode = 0222;
d->qid = (Qid){PATH(g->num, 0), 0, 0};
return 0;
}
i--;
}

/* group directory: child articles */
ndir = g->hi - g->lo;
if(i < ndir){
sprint(buf, "%d", g->lo+i);
d->name = estrdup(buf);
d->mode = DMDIR|0555;
d->qid = (Qid){PATH(g->num, i+1), 0, QTDIR};
return 0;
}

return -1;
}

static void
fsstat(Req *r)
{
Aux *a;

a = r->fid->aux;
if(r->fid->qid.path == 0 && (r->fid->qid.type & QTDIR))
nntprefreshall(net);
else if(a->g->isgroup)
nntprefresh(net, a->g);
fillstat(&r->d, a);
respond(r, nil);
}

static void
fsread(Req *r)
{
int offset, n;
Aux *a;
char *p, *ep;
Dir d;

a = r->fid->aux;
if(a->s){
readstr(r, a->s);
respond(r, nil);
return;
}

if(r->ifcall.offset == 0)
offset = 0;
else
offset = a->offset;

p = r->ofcall.data;
ep = r->ofcall.data+r->ifcall.count;
for(; p+2 < ep; p += n){
if(dirfillstat(&d, a, offset) < 0)
break;
n=convD2M(&d, (uchar*)p, ep-p);
free(d.name);
free(d.uid);
free(d.gid);
free(d.muid);
if(n <= BIT16SZ)
break;
offset++;
}
a->offset = offset;
r->ofcall.count = p - r->ofcall.data;
respond(r, nil);
}

static void
fswrite(Req *r)
{
Aux *a;
long count;
vlong offset;

a = r->fid->aux;

if(r->ifcall.count == 0){ /* commit */
respond(r, nntppost(net, a->s));
free(a->s);
a->ns = 0;
a->s = nil;
return;
}

count = r->ifcall.count;
offset = r->ifcall.offset;
if(a->ns < count+offset+1){
a->s = erealloc(a->s, count+offset+1);
a->ns = count+offset;
a->s[a->ns] = '\0';
}
memmove(a->s+offset, r->ifcall.data, count);
r->ofcall.count = count;
respond(r, nil);
}

static void
fsdestroyfid(Fid *fid)
{
Aux *a;

a = fid->aux;
if(a==nil)
return;

if(a->ispost && a->s)
nntppost(net, a->s);

free(a->s);
free(a);
}

Srv nntpsrv = {
destroyfid= fsdestroyfid,
attach= fsattach,
clone= fsclone,
walk1= fswalk1,
open= fsopen,
read= fsread,
write= fswrite,
stat= fsstat,
};

void
usage(void)
{
fprint(2, "usage: nntpsrv [-a] [-s service] [-m mtpt] [nntp.server]\n");
exits("usage");
}

void
dumpgroups(Group *g, int ind)
{
int i;

print("%*s%s\n", ind*4, "", g->name);
for(i=0; i<g->nkid; i++)
dumpgroups(g->kid[i], ind+1);
}

void
main(int argc, char **argv)
{
int auth, x;
char *mtpt, *service, *where, *user;
Netbuf n;
UserPasswd *up;

mtpt = "/mnt/news";
service = nil;
memset(&n, 0, sizeof n);
user = nil;
auth = 0;
ARGBEGIN{
case 'D':
chatty9p++;
break;
case 'N':
netdebug = 1;
break;
case 'a':
auth = 1;
break;
case 'u':
user = EARGF(usage());
break;
case 's':
service = EARGF(usage());
break;
case 'm':
mtpt = EARGF(usage());
break;
default:
usage();
}ARGEND

if(argc > 1)
usage();
if(argc==0)
where = "$nntp";
else
where = argv[0];

now = time(0);

net = &n;
if(auth) {
n.auth = 1;
if(user)
up = auth_getuserpasswd(auth_getkey, "proto=pass service=nntp server=%q user=%q", where, user);
else
up = auth_getuserpasswd(auth_getkey, "proto=pass service=nntp server=%q", where);
if(up == nil)
sysfatal("no password: %r");

n.user = up->user;
n.pass = up->passwd;
}

n.addr = netmkaddr(where, "tcp", "nntp");

root = emalloc(sizeof *root);
root->name = estrdup("");
root->parent = root;

n.fd = -1;
if(nntpconnect(&n) < 0)
sysfatal("nntpconnect: %s", n.response);

x=netdebug;
netdebug=0;
nntprefreshall(&n);
netdebug=x;
// dumpgroups(root, 0);

postmountsrv(&nntpsrv, service, mtpt, MREPL);
exits(nil);
}


</pre>
</td></tr></table>
</td></tr></table>





<center><table border="0"><tr>
<td valign="middle"><a href="http://www.alcatel-lucent.com/"><img border="0" src="/plan9/img/logo_ft.gif" alt="Bell Labs" />
</a></td>
<td valign="middle"><a href="http://www.opensource.org"><img border="0" alt="OSI certified" src="/plan9/img/osi-certified-60x50.gif" />
</a></td>
<td><img style="padding-right: 45px;" alt="Powered by Plan 9" src="/plan9/img/power36.gif" />
</td>
</tr></table></center>

<center>
(<a href="/plan9/">Return to Plan 9 Home Page</a>)
</center>

<center>
<a href="http://www.lucent.com/copyright.html">Copyright</a>
© 2009 Alcatel-Lucent.
All Rights Reserved.
 
Comments to
<a href="mailto:[email protected]">[email protected]</a>.
</center>
</body>
</html>