2 * Copyright (c) 1999-2001 Boris Popov
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
8 * 1. Redistributions of source code must retain the above copyright
9 * notice, this list of conditions and the following disclaimer.
10 * 2. Redistributions in binary form must reproduce the above copyright
11 * notice, this list of conditions and the following disclaimer in the
12 * documentation and/or other materials provided with the distribution.
14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND
15 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
17 * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
18 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
19 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
20 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
21 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
22 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
23 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
26 * Routines to prepare request and fetch reply
29 #include <sys/cdefs.h>
30 __FBSDID("$FreeBSD$");
32 #include <sys/param.h>
33 #include <sys/systm.h>
34 #include <sys/errno.h>
35 #include <sys/kernel.h>
36 #include <sys/malloc.h>
40 #include <sys/socket.h>
41 #include <sys/socketvar.h>
44 #include <netncp/ncp.h>
45 #include <netncp/ncp_conn.h>
46 #include <netncp/ncp_rq.h>
47 #include <netncp/ncp_subr.h>
48 #include <netncp/ncp_ncp.h>
49 #include <netncp/ncp_sock.h>
50 #include <netncp/ncp_nls.h>
52 static MALLOC_DEFINE(M_NCPRQ, "NCPRQ", "NCP request");
54 static int ncp_sign_packet(struct ncp_conn *conn, struct ncp_rq *rqp, int *size);
57 ncp_rq_alloc_any(u_int32_t ptype, u_int8_t fn, struct ncp_conn *ncp,
58 struct thread *td, struct ucred *cred,
64 rqp = malloc(sizeof(*rqp), M_NCPRQ, M_WAITOK);
65 error = ncp_rq_init_any(rqp, ptype, fn, ncp, td, cred);
66 rqp->nr_flags |= NCPR_ALLOCED;
76 ncp_rq_alloc(u_int8_t fn, struct ncp_conn *ncp,
77 struct thread *td, struct ucred *cred, struct ncp_rq **rqpp)
79 return ncp_rq_alloc_any(NCP_REQUEST, fn, ncp, td, cred, rqpp);
83 ncp_rq_alloc_subfn(u_int8_t fn, u_int8_t subfn, struct ncp_conn *ncp,
84 struct thread *td, struct ucred *cred, struct ncp_rq **rqpp)
89 error = ncp_rq_alloc_any(NCP_REQUEST, fn, ncp, td, cred, &rqp);
92 mb_reserve(&rqp->rq, 2);
93 mb_put_uint8(&rqp->rq, subfn);
99 ncp_rq_init_any(struct ncp_rq *rqp, u_int32_t ptype, u_int8_t fn,
100 struct ncp_conn *ncp,
101 struct thread *td, struct ucred *cred)
103 struct ncp_rqhdr *rq;
104 struct ncp_bursthdr *brq;
108 bzero(rqp, sizeof(*rqp));
109 error = ncp_conn_access(ncp, cred, NCPM_EXECUTE);
116 if (mb_init(mbp) != 0)
119 case NCP_PACKET_BURST:
120 brq = (struct ncp_bursthdr*)mb_reserve(mbp, sizeof(*brq));
121 brq->bh_type = ptype;
122 brq->bh_streamtype = 0x2;
125 rq = (struct ncp_rqhdr*)mb_reserve(mbp, sizeof(*rq));
127 rq->seq = 0; /* filled later */
131 rqp->nr_minrplen = -1;
136 ncp_rq_done(struct ncp_rq *rqp)
140 if (rqp->nr_flags & NCPR_ALLOCED)
146 * Routines to fill the request
150 ncp_rq_pathstrhelp(struct mbchain *mbp, c_caddr_t src, caddr_t dst,
151 size_t *srclen, size_t *dstlen)
155 if (*srclen < *dstlen) {
162 ncp_pathcopy(src, dst, len, mbp->mb_udata);
167 ncp_rq_pathstring(struct ncp_rq *rqp, int size, const char *name,
168 struct ncp_nlstables *nt)
170 struct mbchain *mbp = &rqp->rq;
172 mb_put_uint8(mbp, size);
173 mbp->mb_copy = ncp_rq_pathstrhelp;
175 return mb_put_mem(mbp, (c_caddr_t)name, size, MB_MCUSTOM);
179 ncp_rq_pstring(struct ncp_rq *rqp, const char *s)
181 u_int len = strlen(s);
186 error = mb_put_uint8(&rqp->rq, len);
189 return mb_put_mem(&rqp->rq, s, len, MB_MSYSTEM);
193 ncp_rq_dbase_path(struct ncp_rq *rqp, u_int8_t vol_num, u_int32_t dir_base,
194 int namelen, u_char *path, struct ncp_nlstables *nt)
196 struct mbchain *mbp = &rqp->rq;
199 mb_put_uint8(mbp, vol_num);
200 mb_put_mem(mbp, (c_caddr_t)&dir_base, sizeof(dir_base), MB_MSYSTEM);
201 mb_put_uint8(mbp, 1); /* with dirbase */
202 if (path != NULL && path[0]) {
205 mb_put_uint8(mbp, namelen);
206 for(; namelen; namelen--) {
208 mb_put_uint8(mbp, complen);
209 mb_put_mem(mbp, path, complen, MB_MSYSTEM);
213 mb_put_uint8(mbp, 1); /* 1 component */
214 ncp_rq_pathstring(rqp, namelen, path, nt);
217 mb_put_uint8(mbp, 0);
218 mb_put_uint8(mbp, 0);
224 * Make a signature for the current packet and add it at the end of the
228 ncp_sign_packet(struct ncp_conn *conn, struct ncp_rq *rqp, int *size)
233 bzero(data, sizeof(data));
234 bcopy(conn->sign_root, data, 8);
235 setdle(data, 8, *size);
236 m_copydata(rqp->rq.mb_top, sizeof(struct ncp_rqhdr) - 1,
237 min((*size) - sizeof(struct ncp_rqhdr)+1, 52), data + 12);
238 ncp_sign(conn->sign_state, data, conn->sign_state);
239 error = mb_put_mem(&rqp->rq, (caddr_t)conn->sign_state, 8, MB_MSYSTEM);
247 * Low level send rpc, here we do not attempt to restore any connection,
248 * Connection expected to be locked
251 ncp_request_int(struct ncp_rq *rqp)
253 struct ncp_conn *conn = rqp->nr_conn;
254 struct thread *td = conn->td;
255 struct socket *so = conn->ncp_so;
256 struct ncp_rqhdr *rq;
257 struct ncp_rphdr *rp=NULL;
259 struct mbuf *m, *mreply = NULL;
261 int error, len, dosend, plen = 0, gotpacket;
264 printf("%s: ncp_so is NULL !\n",__func__);
265 ncp_conn_invalidate(conn);
269 td = curthread; /* XXX maybe procpage ? */
271 * Flush out replies on previous reqs
275 while (selsocket(so, POLLIN, &tv, td) == 0) {
276 if (ncp_sock_recv(so, &m, &len) != 0)
281 len = mb_fixhdr(mbp);
282 rq = mtod(mbp->mb_top, struct ncp_rqhdr *);
287 case 0x15: case 0x16: case 0x17: case 0x23:
288 *(u_int16_t*)(rq + 1) = htons(len - 2 - sizeof(*rq));
291 if (conn->flags & NCPFL_SIGNACTIVE) {
292 error = ncp_sign_packet(conn, rqp, &len);
295 mbp->mb_top->m_pkthdr.len = len;
297 rq->conn_low = conn->connid & 0xff;
298 /* rq->task = p->p_pgrp->pg_id & 0xff; */ /*p->p_pid*/
299 /* XXX: this is temporary fix till I find a better solution */
300 rq->task = rq->conn_low;
301 rq->conn_high = conn->connid >> 8;
302 rqp->rexmit = conn->li.retry_count;
305 if (rqp->rexmit-- == 0) {
311 NCPSDEBUG("send:%04x f=%02x c=%d l=%d s=%d t=%d\n",rq->type, rq->fn, (rq->conn_high << 8) + rq->conn_low,
312 mbp->mb_top->m_pkthdr.len, rq->seq, rq->task
314 error = ncp_sock_send(so, mbp->mb_top, rqp);
318 tv.tv_sec = conn->li.timeout;
320 error = selsocket(so, POLLIN, &tv, td);
321 if (error == EWOULDBLOCK ) /* timeout expired */
323 error = ncp_chkintr(conn, td);
327 * At this point it is possible to get more than one
328 * reply from server. In general, last reply should be for
329 * current request, but not always. So, we loop through
330 * all replies to find the right answer and flush others.
332 gotpacket = 0; /* nothing good found */
333 dosend = 1; /* resend rq if error */
338 if (selsocket(so, POLLIN, &tv, td) != 0)
340 /* if (so->so_rcv.sb_cc == 0) {
343 error = ncp_sock_recv(so, &m, &len);
345 break; /* must be more checks !!! */
346 if (m->m_len < sizeof(*rp)) {
347 m = m_pullup(m, sizeof(*rp));
349 printf("%s: reply too short\n",__func__);
353 rp = mtod(m, struct ncp_rphdr*);
354 if (len == sizeof(*rp) && rp->type == NCP_POSITIVE_ACK) {
355 NCPSDEBUG("got positive acknowledge\n");
357 rqp->rexmit = conn->li.retry_count;
358 dosend = 0; /* server just busy and will reply ASAP */
361 NCPSDEBUG("recv:%04x c=%d l=%d s=%d t=%d cc=%02x cs=%02x\n",rp->type,
362 (rp->conn_high << 8) + rp->conn_low, len, rp->seq, rp->task,
363 rp->completion_code, rp->connection_state);
365 if ( (rp->type == NCP_REPLY) &&
366 ((rq->type == NCP_ALLOC_SLOT) ||
367 ((rp->conn_low == rq->conn_low) &&
368 (rp->conn_high == rq->conn_high)
370 if (rq->seq > rp->seq || (rq->seq == 0 && rp->seq == 0xff)) {
373 if (rp->seq == rq->seq) {
381 continue; /* look up other for other packets */
385 NCPSDEBUG("reply mismatch\n");
387 if (error || gotpacket)
389 /* try to resend, or just wait */
393 NCPSDEBUG("error=%d\n", error);
395 * Any error except interruped call means that we have
396 * to reconnect. So, eliminate future timeouts by invalidating
400 ncp_conn_invalidate(conn);
403 if (conn->flags & NCPFL_SIGNACTIVE) {
404 /* XXX: check reply signature */
408 rp = mtod(mreply, struct ncp_rphdr*);
409 md_initm(&rqp->rp, mreply);
410 rqp->nr_rpsize = plen - sizeof(*rp);
411 rqp->nr_cc = error = rp->completion_code;
413 error |= 0x8900; /* server error */
414 rqp->nr_cs = rp->connection_state;
415 if (rqp->nr_cs & (NCP_CS_BAD_CONN | NCP_CS_SERVER_DOWN)) {
416 NCPSDEBUG("server drop us\n");
417 ncp_conn_invalidate(conn);
420 md_get_mem(&rqp->rp, NULL, sizeof(*rp), MB_MSYSTEM);
425 * Here we will try to restore any loggedin & dropped connection,
426 * connection should be locked on entry
429 ncp_restore_login(struct ncp_conn *conn)
433 printf("ncprq: Restoring connection, flags = %x\n", conn->flags);
434 conn->flags |= NCPFL_RESTORING;
435 error = ncp_conn_reconnect(conn);
436 if (!error && (conn->flags & NCPFL_WASLOGGED))
437 error = ncp_conn_login(conn, conn->td, conn->ucred);
439 ncp_ncp_disconnect(conn);
440 conn->flags &= ~NCPFL_RESTORING;
445 ncp_request(struct ncp_rq *rqp)
447 struct ncp_conn *ncp = rqp->nr_conn;
450 error = ncp_conn_lock(ncp, rqp->nr_td, rqp->nr_cred, NCPM_EXECUTE);
453 rcnt = NCP_RESTORE_COUNT;
455 if (ncp->flags & NCPFL_ATTACHED) {
456 error = ncp_request_int(rqp);
457 if (ncp->flags & NCPFL_ATTACHED)
465 * Do not attempt to restore connection recursively
467 if (ncp->flags & NCPFL_RESTORING) {
471 error = ncp_restore_login(ncp);
475 ncp_conn_unlock(ncp, rqp->nr_td);
477 if (error && (rqp->nr_flags & NCPR_DONTFREEONERR) == 0)