void
main(void)
{
int64_t a2000, a500, tStart, tEnd;
if (!atnotify(printFirst, 1) || !atnotify(failOnSecond, 1)){
fprint(2, "%r\n");
exits("atnotify fails");
}
alarm(2000);
a2000 = nsec();
alarm(500);
a500 = nsec();
tStart = nsec();
sleep(1000);
tEnd = nsec();
if(verbose)
fprint(2, "%d: set alarm(2000)@%lld then alarm(500)@%lld; elapsed in sleep() %lld nanosecond\n", getpid(), a2000, a500, tEnd-tStart);
if(tEnd-tStart > 1200 * 1000 * 1000){
print("FAIL: should sleep less\n");
exits("FAIL");
}
if(tEnd-tStart < 800 * 1000 * 1000){
print("FAIL: should sleep more\n");
exits("FAIL");
}
print("PASS\n");
exits("PASS");
}
void
main(int argc, char **argv)
{
char buf[512];
vlong size;
vlong pos;
vlong ns;
int fd;
int i;
if(argc != 2) {
fprint(2, "usage: %s /dev/sd??/data\n", argv[0]);
exits("usage");
}
srand(time(0));
fd = open(argv[1], OREAD);
if(fd < 0)
sysfatal("open: %r");
size = seek(fd, 0, 2) / 512;
ns = nsec();
for(i=0;i<100;i++) {
pos = (vlong)(frand() * size);
if(pread(fd, buf, 512, 512 * pos) < 512)
sysfatal("read: %r");
}
ns = nsec() - ns;
print("%.3g\n", ((double)ns)/100000000);
exits(nil);
}
void
spawnWaiter(Lock *l)
{
int pid;
int64_t start;
switch((pid = rfork(RFMEM|RFPROC|RFNOWAIT)))
{
case 0:
/* wait for the alwaysLocked to be locked by the main process */
qlock(&rl);
while(resInWaiter == 0xff)
rsleep(&rStart);
start = nsec();
resInWaiter = lockt(l, 6000);
elapsedInWaiter = (nsec() - start) / (1000 * 1000);
if(verbose)
print("lockt returned %d, elapsed = %d ms\n", resInWaiter, elapsedInWaiter);
rwakeup(&rCompleted);
qunlock(&rl);
exits(0);
break;
case -1:
print("spawnWaiter: %r\n");
exits("rfork fails");
break;
default:
if(verbose)
print("spawn waiter %d\n", pid);
break;
}
}
void
main(void)
{
int ret = 0; // success
uint64_t start, end;
char *msg;
start = nsec();
sleep(1);
end = nsec();
if (end <= start)
ret = 1;
if (verbose)
print("nanotime: start %llx, end %llx\n", start, end);
if(ret){
msg = smprint("nanotime: FAIL: start %llx end %llx",
start, end);
print("%s\n", msg);
exits(msg);
}
print("PASS\n");
exits("PASS");
}
static void
periodicThread(void *a)
{
Periodic *p = a;
double t, ct, ts;
vtThreadSetName("periodic");
ct = nsec()*1e-6;
t = ct + p->msec;
for(;;){
/* skip missed */
while(t <= ct)
t += p->msec;
ts = t - ct;
if(ts > 1000)
ts = 1000;
sleep(ts);
ct = nsec()*1e-6;
vtLock(p->lk);
if(p->die){
vtUnlock(p->lk);
break;
}
if(t <= ct){
p->f(p->a);
t += p->msec;
}
vtUnlock(p->lk);
}
periodicFree(p);
}
static void
periodicThread(void *a)
{
Periodic *p = a;
vlong t, ct, ts; /* times in ms. */
threadsetname("periodic");
ct = nsec() / 1000000;
t = ct + p->msec; /* call p->f at or after this time */
for(;;){
ts = t - ct; /* ms. to next cycle's start */
if(ts > 1000)
ts = 1000; /* bound sleep duration */
if(ts > 0)
sleep(ts); /* wait for cycle's start */
qlock(&p->lk);
if(p->die){
qunlock(&p->lk);
break;
}
ct = nsec() / 1000000;
if(t <= ct){ /* due to call p->f? */
p->f(p->a);
ct = nsec() / 1000000;
while(t <= ct) /* advance t to future cycle start */
t += p->msec;
}
qunlock(&p->lk);
}
periodicFree(p);
}
void
main(void)
{
int64_t start, elapsed, res;
static Lock l;
rfork(RFNOTEG|RFREND);
rStart.l = &rl;
rCompleted.l = &rl;
resInWaiter = 0xff;
spawnWaiter(&l);
lock(&l);
alarm(20000); /* global timeout, FAIL if reached */
if (!atnotify(failOnTimeout, 1)){
fprint(2, "%r\n");
exits("atnotify fails");
}
/* verify that lockt returns 0 on timeout */
start = nsec();
res = lockt(&l, 1000);
elapsed = (nsec() - start) / (1000 * 1000);
if(verbose)
print("lockt returned %d, elapsed = %d ms\n", res, elapsed);
if(res != 0 || elapsed < 900 || elapsed > 1300){
print("FAIL: lockt timeout\n");
exits("FAIL");
}
/* verify that lockt returns 1 if the lock is released and
* it can take it
*/
resInWaiter = -1;
qlock(&rl);
rwakeupall(&rStart);
qunlock(&rl);
sleep(1200);
unlock(&l);
qlock(&rl);
while(elapsedInWaiter == 0)
rsleep(&rCompleted);
qunlock(&rl);
if(resInWaiter != 1 || elapsedInWaiter < 1100 || elapsedInWaiter > 1500){
print("FAIL: lockt delayed acquisition\n");
exits("FAIL");
}
print("PASS\n");
exits("PASS");
}
/*
* May be called with null parent, for root and ctl files.
* The first call with a null parent is root, all others are ctl
* files linked at root.
*/
Memblk*
dfcreate(Memblk *parent, char *name, int uid, ulong mode)
{
Memblk *nf;
Mfile *m;
int isctl;
if(fsfull())
error("file system full");
isctl = parent == nil;
if(parent == nil)
parent = fs->root;
if(parent != nil){
dprint("dfcreate '%s' %M at\n%H\n", name, mode, parent);
isdir(parent);
isrwlocked(parent, Wr);
ismelted(parent);
}else
dprint("dfcreate '%s' %M", name, mode);
if(isctl)
nf = dballoc(DBctl);
else
nf = dballoc(DBfile);
if(catcherror()){
mbput(nf);
if(parent != nil)
rwunlock(parent, Wr);
error(nil);
}
m = nf->mf;
nf->d.id = nsec();
nf->d.mode = mode;
nf->d.mtime = nf->d.id;
nf->d.atime = nf->d.id;
nf->d.length = 0;
m->uid = usrname(uid);
nf->d.uid = uid;
m->gid = m->uid;
nf->d.gid = nf->d.uid;
m->muid = m->uid;
nf->d.muid = nf->d.uid;
m->name = name;
nf->d.asize = pmeta(nf->d.embed, Embedsz, nf);
changed(nf);
if(parent != nil){
m->gid = parent->mf->gid;
nf->d.gid = parent->d.gid;
dflink(parent, nf);
}
noerror();
dprint("dfcreate-> %H\n within %H\n", nf, parent);
return nf;
}
uint taskdelay(uint ms)
{
uvlong when = 0L;
uvlong now = 0L;
Task *t = NULL;
startfdtask();
now = nsec();
when = now + (uvlong)ms * 1000000;
for(t=sleeping.head; t != NULL && t->alarmtime < when; t=t->next)
;
if(t) {
taskrunning->prev = t->prev;
taskrunning->next = t;
} else {
taskrunning->prev = sleeping.tail;
taskrunning->next = NULL;
}
t = taskrunning;
t->alarmtime = when;
if(t->prev) {
t->prev->next = t;
} else {
sleeping.head = t;
}
if(t->next) {
t->next->prev = t;
} else {
sleeping.tail = t;
}
if(!t->system && sleepingcounted++ == 0) {
taskcount++;
}
taskswitch();
return (nsec() - now) / 1000000;
}
void
main(int argc, char *argv[])
{
int i;
uint64_t start, stop;
char buf[1];
(void) close(3);
start = nsec();
for(i = 0; i < 1000000000; i++) {
if (read(3, buf, 1) >= 0){
fprint(2, "Read of 3 did not fail!\n");
exits("benchmark broken");
}
}
stop = nsec();
print("# error benchmark\n");
print("1000000 %lld\n", stop - start);
}
uint
taskdelay(uint ms)
{
uvlong when, now;
Task *t;
if(!startedfdtask){
startedfdtask = 1;
epfd = epoll_create(1);
assert(epfd >= 0);
taskcreate(fdtask, 0, 32768 * 10);
}
now = nsec();
when = now+(uvlong)ms*1000000;
for(t=sleeping.head; t!=nil && t->alarmtime < when; t=t->next)
;
if(t){
taskrunning->prev = t->prev;
taskrunning->next = t;
}else{
taskrunning->prev = sleeping.tail;
taskrunning->next = nil;
}
t = taskrunning;
t->alarmtime = when;
if(t->prev)
t->prev->next = t;
else
sleeping.head = t;
if(t->next)
t->next->prev = t;
else
sleeping.tail = t;
if(!t->system && sleepingcounted++ == 0)
taskcount++;
taskswitch();
return (nsec() - now)/1000000;
}
void
main(int argc, char *argv[])
{
int n;
Biobuf in;
char *p;
char *f[4];
strcpy(mntpt, "/net");
cfg.inside = 1;
ARGBEGIN{
case 'f':
dbfile = EARGF(usage());
break;
case 'r':
cfg.resolver = 1;
break;
case 'x':
dbfile = "/lib/ndb/external";
strcpy(mntpt, "/net.alt");
break;
default:
usage();
}ARGEND
now = time(nil);
nowns = nsec();
dninit();
fmtinstall('R', prettyrrfmt);
if(myipaddr(ipaddr, mntpt) < 0)
sysfatal("can't read my ip address");
opendatabase();
if(cfg.resolver)
squirrelserveraddrs();
debug = 1;
if(argc > 0){
docmd(argc, argv);
exits(0);
}
Binit(&in, 0, OREAD);
for(print("> "); p = Brdline(&in, '\n'); print("> ")){
p[Blinelen(&in)-1] = 0;
n = tokenize(p, f, 3);
if(n>=1) {
dnpurge(); /* flush the cache */
docmd(n, f);
}
}
exits(0);
}
void
dfused(Path *p)
{
Memblk *f;
f = p->f[p->nf-1];
isfile(f);
rwlock(f, Wr);
f->d.atime = nsec();
rwunlock(f, Wr);
}
int
timefmt(Fmt *fmt)
{
vlong ns;
Tm tm;
ns = nsec();
tm = *localtime(time(0));
return fmtprint(fmt, "%04d/%02d%02d %02d:%02d:%02d.%03d",
tm.year+1900, tm.mon+1, tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}
int
printFirst(void *v, char *s)
{
/* just not exit, please */
if(strcmp(s, "alarm") == 0){
if(verbose)
fprint(2, "%d: noted: %s at %lld\n", getpid(), s, nsec());
atnotify(printFirst, 0);
return 1;
}
return 0;
}
ulong
etimer(ulong key, int n)
{
if(Stimer != -1)
drawerror(display, "events: timer started twice");
Stimer = newkey(key);
if(n <= 0)
n = 1000;
eslave[Stimer].n = n;
eslave[Stimer].nexttick = nsec()+n*1000000LL;
return 1<<Stimer;
}
void
main(int argc, char **argv)
{
Memimage *x;
Point c = {208,871};
int a = 441;
int b = 441;
int thick = 0;
Point sp = {0,0};
int alpha = 51;
int phi = 3;
vlong t0, t1;
int i, n;
vlong del;
if (argc != 2) {
fprint(2, "usage: arctest number\n");
exits("usage");
}
memimageinit();
x = allocmemimage(Rect(0,0,1000,1000), CMAP8);
n = atoi(argv[1]);
t0 = nsec();
t0 = nsec();
t0 = nsec();
t1 = nsec();
del = t1-t0;
t0 = nsec();
for(i=0; i<n; i++)
memarc(x, c, a, b, thick, memblack, sp, alpha, phi, SoverD);
t1 = nsec();
print("%lld %lld\n", t1-t0-del, del);
}
static inline void wake_sleepers()
{
Task *t;
uvlong now = nsec();
while((t =sleeping.head) && now >= t->alarmtime){
deltask(&sleeping, t);
if(!t->system && --sleepingcounted == 0) taskcount--;
taskready(t);
}
}
int
timefmt(Fmt *fmt)
{
static char *mon[] = { "Jan", "Feb", "Mar", "Apr", "May", "Jun",
"Jul", "Aug", "Sep", "Oct", "Nov", "Dec" };
vlong ns;
Tm tm;
ns = nsec();
tm = *localtime(time(0));
return fmtprint(fmt, "%s %2d %02d:%02d:%02d.%03d",
mon[tm.mon], tm.mday, tm.hour, tm.min, tm.sec,
(int)(ns%1000000000)/1000000);
}
int fdcheckblock(int fd)
{
uvlong now,when;
Task* t;
now = nsec();
struct timeval stTime;
socklen_t len = sizeof(stTime);
if(getsockopt(fd,SOL_SOCKET,SO_RCVTIMEO,&stTime,&len) == 0){
when = now + stTime.tv_sec * 1000 * 1000000 + stTime.tv_usec;
if (when == now){
return 0;
}
}else{
fprintf(stderr,"getsockopt failed:%s\n",strerror(errno));
return 0;
}
for(t=blocking.head; t!=nil && t->alarmtime < when; t=t->next)
;
if(t){
taskrunning->prev = t->prev;
taskrunning->next = t;
}else{
taskrunning->prev = blocking.tail;
taskrunning->next = nil;
}
t = taskrunning;
t->alarmtime = when;
if(t->prev)
t->prev->next = t;
else
blocking.head = t;
if(t->next)
t->next->prev = t;
else
blocking.tail = t;
if(!t->system && blockingcounted++ == 0)
taskcount++;
return 1;
}
void NeatLearner::updatePose(const boost::shared_ptr<::gazebo::msgs::PosesStamped const> &msg)
{
for (int i = 0; i < msg->pose_size(); ++i) {
auto poseMsg = msg->pose(i);
auto name = poseMsg.name();
if (name == this->modelName_) {
auto position = poseMsg.position();
this->position_[0] = position.x();
this->position_[1] = position.y();
this->position_[2] = position.z();
}
}
auto timeStamp = msg->time();
double seconds = (double)timeStamp.sec();
double nanoseconds = (double)timeStamp.nsec() / 1000000000.0;
this->currentTime_ = seconds + nanoseconds;
}
struct api_thread *
api_add_thread(struct gspos pos, struct api_thread_table *api_thread_table, void *main_thread_data, struct api_prim_table *api_prim_table, gsvalue entry)
{
int i;
struct api_thread *thread;
api_take_thread_queue();
thread = 0;
for (i = 0; i < API_NUMTHREADS; i++) {
api_take_thread(&api_thread_queue->threads[i]);
if (api_thread_queue->threads[i].state == api_thread_st_unused) {
thread = &api_thread_queue->threads[i];
api_thread_queue->numthreads++;
goto have_thread;
} else {
api_release_thread(&api_thread_queue->threads[i]);
}
}
gsfatal(UNIMPL("thread queue overflow"));
have_thread:
api_release_thread_queue();
if (gsflag_stat_collection) {
thread->start_time = nsec();
thread->prog_term_time = 0;
}
thread->state = api_thread_st_active;
thread->ismain = 0;
thread->api_thread_table = api_thread_table;
thread->api_prim_table = api_prim_table;
thread->client_data = main_thread_data;
thread->status = 0;
thread->code = api_alloc_code_segment(pos, thread, entry);
thread->eprim_blocking = 0;
return thread;
}
/*
* Report that a file has been modified.
* Modification times propagate up to the root of the file tree.
* But frozen files are never changed.
*/
void
dfchanged(Path *p, int muid)
{
Memblk *f;
u64int t, u;
int i;
t = nsec();
u = muid;
for(i = 0; i < p->nf; i++){
f = p->f[i];
rwlock(f, Wr);
if(f->frozen == 0)
if(!catcherror()){
f->d.mtime = t;
f->d.atime = t;
f->d.muid = muid;
changed(f);
noerror();
}
rwunlock(f, Wr);
}
}
void
yurexread(Req *r)
{
int qid = (int)r->fid->qid.path;
char data[32];
vlong tnsec;
switch(qid){
case Qbbu:
seprint(data, data+sizeof(data), "%ld\n", yc.curval);
readstr(r, data);
break;
case Qmbbups:
tnsec = nsec();
if(tnsec == yc.oldnsec) tnsec++;
seprint(data, data+sizeof(data), "%lld\n", (yc.curval-yc.oldval)*1000*10000/((tnsec-yc.oldnsec)/100000));
readstr(r, data);
yc.oldval = yc.curval;
yc.oldnsec = tnsec;
}
respond(r, nil);
}
static inline int next_task_sleeptime(int min)
{
Task *t;
uvlong now = 0;
int ms = 0;
if((t=sleeping.head) == NULL)
ms = -1;
else{
now = nsec();
if(now >= t->alarmtime) {
ms = 0;
} else {
ms = (t->alarmtime - now) / 1000000;
}
if(ms % min != 0) ms = ms - (ms % min);
}
if(ms == 0) ms = min;
return ms;
}
static void
X917(uint8_t *rand, int nrand)
{
int i, m, n8;
uint64_t I, x;
/* 1. Compute intermediate value I = Ek(time). */
I = nsec();
triple_block_cipher(x917state.des3.expanded, (uint8_t*)&I, 0); /* two-key EDE */
/* 2. x[i] = Ek(I^seed); seed = Ek(x[i]^I); */
m = (nrand+7)/8;
for(i=0; i<m; i++){
x = I ^ x917state.seed;
triple_block_cipher(x917state.des3.expanded, (uint8_t*)&x, 0);
n8 = (nrand>8) ? 8 : nrand;
memcpy(rand, (uint8_t*)&x, n8);
rand += 8;
nrand -= 8;
x ^= I;
triple_block_cipher(x917state.des3.expanded, (uint8_t*)&x, 0);
x917state.seed = x;
}
}
static void
yurexwork(void *)
{
char buf[8];
ulong val;
int yfd;
int c;
yfd = yc.ep->dfd;
yc.issueing_cmd = YCMD_NONE;
yc.accepted_cmd = YCMD_NONE;
print("YUREX: maxpkt = %d dfd = %d\n", yc.ep->maxpkt, yfd);
//set mode
memset(buf, YCMD_PADDING, sizeof(buf));
buf[0] = YCMD_MODE;
buf[1] = 0;
buf[2] = YCMD_EOF;
write(yfd, buf, sizeof(buf));
sleep(500);
//read value request
memset(buf, YCMD_PADDING, sizeof(buf));
buf[0] = YCMD_READ;
buf[1] = YCMD_EOF;
yc.issueing_cmd = YCMD_READ;
yc.accepted_cmd = YCMD_NONE;
write(yfd, buf, sizeof(buf));
sleep(500);
for(;;){
if(yc.ep == nil) sysfatal(nil);
memset(buf, YCMD_PADDING, sizeof(buf));
c = read(yfd, buf, sizeof(buf));
if(c <= 0) sysfatal("%r");
switch(buf[0]){
case YCMD_ACK:
if(buf[1] == yc.issueing_cmd){
fprint(2, "YUREX DEBUG: ack cmd 0x%.2x\n", buf[1]);
yc.accepted_cmd = buf[1];
}else{
fprint(2, "YUREX DEBUG: cmd-ack mismatch: recvd:0x%.2x expect 0x%.02x\n",
buf[1], yc.issueing_cmd);
yc.issueing_cmd = YCMD_NONE;
yc.accepted_cmd = YCMD_NONE;
}
break;
case YCMD_READ:
case YCMD_VALUE:
val = (buf[2]<<24) + (buf[3]<<16) + (buf[4]<<8) + buf[5];
if(yc.initialized == 0){
yc.oldval = val;
yc.oldnsec = nsec();
yc.initialized = 1;
}
yc.curval = val;
//fprint(2, "YUREX DEBUG: BBU %ld\n", val);
break;
default:
fprint(2, "YUREX DEBUG: unknown message: 0x%.2x\n", buf[0]);
}
}
}
uint
msec(void)
{
return nsec()/1000000;
}
void
fdtask(void *v)
{
int i, ms;
Task *t;
uvlong now;
tasksystem();
taskname("fdtask");
for(;;){
//fprintf(stderr,"pooling0\n");
/* let everyone else run */
taskyield();
//fprintf(stderr,"\n after yield %d\n", maysamYieldRet);
//while(taskyield() > 0);
/* we're the only one runnable - poll for i/o */
errno = 0;
taskstate("poll");
//Added by Maysam Yabandeh
//taskname("fdtask(%d)",npollfd);
if((t=sleeping.head) == nil)
ms = -1;
else{
/* sleep at most 5s */
now = nsec();
if(now >= t->alarmtime)
ms = 0;
else if(now+5*1000*1000*1000LL >= t->alarmtime)
ms = (t->alarmtime - now)/1000000;
else
ms = 5000;
}
//Added by Maysam Yabandeh
//if (ms == -1 && maysamYieldRet == 0) ms = 0;
if (ms == -1) ms = 0;
//fprintf(stderr,"pooling ms is %d npollfd is %d\n", ms, npollfd);
#ifndef USE_SHM
if(poll(pollfd, npollfd, ms) < 0){
//fprintf(stderr,"pooling error\n");
if(errno == EINTR)
continue;
fprint(2, "poll: %s\n", strerror(errno));
taskexitall(0);
}
//fprintf(stderr,"pooling2\n");
/* wake up the guys who deserve it */
for(i=0; i<npollfd; i++){
while(i < npollfd && pollfd[i].revents){
//fprintf(stderr,"pooling3\n");
taskready(polltask[i]);
--npollfd;
pollfd[i] = pollfd[npollfd];
polltask[i] = polltask[npollfd];
}
}
#else
/* wake up the guys who deserve it */
//extern mpass::MessageEndPoint msg_end_point;
mpass::MessageEndPoint *end_point = &mpass::msg_end_point;
for(i=0; i<npollfd; i++){
int &fd = pollfd[i].fd;
bool read = pollfd[i].events & POLLIN;
mpass::Connection *conn = &end_point->conn_array[fd];
if ( (read && !conn->rcv_q->is_empty()) || (!read && !conn->snd_q->is_full()) )
{
taskready(polltask[i]);
--npollfd;
pollfd[i] = pollfd[npollfd];
polltask[i] = polltask[npollfd];
}
}
#endif
//fprintf(stderr,"pooling4\n");
now = nsec();
while((t=sleeping.head) && now >= t->alarmtime){
//fprintf(stderr,"pooling5\n");
deltask(&sleeping, t);
if(!t->system && --sleepingcounted == 0)
taskcount--;
taskready(t);
}
}
}
SmbProcessResult
smbnegotiate(SmbSession *s, SmbHeader *h, uchar *, SmbBuffer *b)
{
ushort index;
int i;
uchar bufferformat;
if (!smbcheckwordcount("negotiate", h, 0))
return SmbProcessResultFormat;
if (s->state != SmbSessionNeedNegotiate) {
/* this acts as a complete session reset */
smblogprint(-1, "smbnegotiate: called when already negotiated\n");
return SmbProcessResultUnimp;
}
i = 0;
index = 0xffff;
while (smbbuffergetb(b, &bufferformat)) {
char *s;
if (bufferformat != 0x02) {
smblogprint(-1, "smbnegotiate: unrecognised buffer format 0x%.2ux\n", bufferformat);
return SmbProcessResultFormat;
}
if (!smbbuffergetstr(b, 0, &s)) {
smblogprint(-1, "smbnegotiate: no null found\n");
return SmbProcessResultFormat;
}
smblogprint(h->command, "smbnegotiate: '%s'\n", s);
if (index == 0xffff && strcmp(s, "NT LM 0.12") == 0)
index = i;
i++;
free(s);
}
if (index != 0xffff) {
Tm *tm;
ulong capabilities;
ulong bytecountfixupoffset;
h->wordcount = 17;
if (!smbbufferputheader(s->response, h, nil)
|| !smbbufferputs(s->response, index)
|| !smbbufferputb(s->response, 3) /* user security, encrypted */
|| !smbbufferputs(s->response, 1) /* max mux */
|| !smbbufferputs(s->response, 1) /* max vc */
|| !smbbufferputl(s->response, smbglobals.maxreceive) /* max buffer size */
|| !smbbufferputl(s->response, 0x10000) /* max raw */
|| !smbbufferputl(s->response, threadid())) /* session key */
goto die;
/* <= Win2k insist upon this being set to ensure that they observe the prototol (!) */
capabilities = CAP_NT_SMBS;
if (smbglobals.unicode)
capabilities |= CAP_UNICODE;
tm = localtime(time(nil));
s->tzoff = tm->tzoff;
if (!smbbufferputl(s->response, capabilities)
|| !smbbufferputv(s->response, nsec() / 100 + (vlong)10000000 * 11644473600LL)
|| !smbbufferputs(s->response, -s->tzoff / 60)
|| !smbbufferputb(s->response, 8)) /* crypt len */
goto die;
bytecountfixupoffset = smbbufferwriteoffset(s->response);
if (!smbbufferputs(s->response, 0))
goto die;
s->cs = auth_challenge("proto=mschap role=server");
if (s->cs == nil) {
smblogprint(h->command, "smbnegotiate: couldn't get mschap challenge\n");
return SmbProcessResultMisc;
}
if (s->cs->nchal != 8) {
smblogprint(h->command, "smbnegotiate: nchal %d\n", s->cs->nchal);
return SmbProcessResultMisc;
}
if (!smbbufferputbytes(s->response, s->cs->chal, s->cs->nchal)
|| !smbbufferputstring(s->response, nil, SMB_STRING_UNICODE, smbglobals.primarydomain)
|| !smbbufferfixuprelatives(s->response, bytecountfixupoffset))
goto die;
}
else {
h->wordcount = 1;
if (!smbbufferputheader(s->response, h, nil)
|| !smbbufferputs(s->response, index)
|| !smbbufferputs(s->response, 0))
goto die;
}
s->state = SmbSessionNeedSetup;
return SmbProcessResultReply;
die:
return SmbProcessResultDie;
}
