LXR linux/fs/ncpfs/sock.c

   1/*
   2 *  linux/fs/ncpfs/sock.c
   3 *
   4 *  Copyright (C) 1992, 1993  Rick Sladkey
   5 *
   6 *  Modified 1995, 1996 by Volker Lendecke to be usable for ncp
   7 *  Modified 1997 Peter Waltenberg, Bill Hawes, David Woodhouse for 2.1 dcache
   8 *
   9 */
  10
  11
  12#include <linux/time.h>
  13#include <linux/errno.h>
  14#include <linux/socket.h>
  15#include <linux/fcntl.h>
  16#include <linux/stat.h>
  17#include <linux/string.h>
  18#include <asm/uaccess.h>
  19#include <linux/in.h>
  20#include <linux/net.h>
  21#include <linux/mm.h>
  22#include <linux/netdevice.h>
  23#include <linux/signal.h>
  24#include <linux/slab.h>
  25#include <net/scm.h>
  26#include <net/sock.h>
  27#include <linux/ipx.h>
  28#include <linux/poll.h>
  29#include <linux/file.h>
  30
  31#include "ncp_fs.h"
  32
  33#include "ncpsign_kernel.h"
  34
  35static int _recv(struct socket *sock, void *buf, int size, unsigned flags)
  36{
  37        struct msghdr msg = {NULL, };
  38        struct kvec iov = {buf, size};
  39        return kernel_recvmsg(sock, &msg, &iov, 1, size, flags);
  40}
  41
  42static inline int do_send(struct socket *sock, struct kvec *vec, int count,
  43                          int len, unsigned flags)
  44{
  45        struct msghdr msg = { .msg_flags = flags };
  46        return kernel_sendmsg(sock, &msg, vec, count, len);
  47}
  48
  49static int _send(struct socket *sock, const void *buff, int len)
  50{
  51        struct kvec vec;
  52        vec.iov_base = (void *) buff;
  53        vec.iov_len = len;
  54        return do_send(sock, &vec, 1, len, 0);
  55}
  56
  57struct ncp_request_reply {
  58        struct list_head req;
  59        wait_queue_head_t wq;
  60        atomic_t refs;
  61        unsigned char* reply_buf;
  62        size_t datalen;
  63        int result;
  64        enum { RQ_DONE, RQ_INPROGRESS, RQ_QUEUED, RQ_IDLE, RQ_ABANDONED } status;
  65        struct kvec* tx_ciov;
  66        size_t tx_totallen;
  67        size_t tx_iovlen;
  68        struct kvec tx_iov[3];
  69        u_int16_t tx_type;
  70        u_int32_t sign[6];
  71};
  72
  73static inline struct ncp_request_reply* ncp_alloc_req(void)
  74{
  75        struct ncp_request_reply *req;
  76
  77        req = kmalloc(sizeof(struct ncp_request_reply), GFP_KERNEL);
  78        if (!req)
  79                return NULL;
  80
  81        init_waitqueue_head(&req->wq);
  82        atomic_set(&req->refs, (1));
  83        req->status = RQ_IDLE;
  84
  85        return req;
  86}
  87
  88static void ncp_req_get(struct ncp_request_reply *req)
  89{
  90        atomic_inc(&req->refs);
  91}
  92
  93static void ncp_req_put(struct ncp_request_reply *req)
  94{
  95        if (atomic_dec_and_test(&req->refs))
  96                kfree(req);
  97}
  98
  99void ncp_tcp_data_ready(struct sock *sk, int len)
 100{
 101        struct ncp_server *server = sk->sk_user_data;
 102
 103        server->data_ready(sk, len);
 104        schedule_work(&server->rcv.tq);
 105}
 106
 107void ncp_tcp_error_report(struct sock *sk)
 108{
 109        struct ncp_server *server = sk->sk_user_data;
 110        
 111        server->error_report(sk);
 112        schedule_work(&server->rcv.tq);
 113}
 114
 115void ncp_tcp_write_space(struct sock *sk)
 116{
 117        struct ncp_server *server = sk->sk_user_data;
 118        
 119        /* We do not need any locking: we first set tx.creq, and then we do sendmsg,
 120           not vice versa... */
 121        server->write_space(sk);
 122        if (server->tx.creq)
 123                schedule_work(&server->tx.tq);
 124}
 125
 126void ncpdgram_timeout_call(unsigned long v)
 127{
 128        struct ncp_server *server = (void*)v;
 129        
 130        schedule_work(&server->timeout_tq);
 131}
 132
 133static inline void ncp_finish_request(struct ncp_server *server, struct ncp_request_reply *req, int result)
 134{
 135        req->result = result;
 136        if (req->status != RQ_ABANDONED)
 137                memcpy(req->reply_buf, server->rxbuf, req->datalen);
 138        req->status = RQ_DONE;
 139        wake_up_all(&req->wq);
 140        ncp_req_put(req);
 141}
 142
 143static void __abort_ncp_connection(struct ncp_server *server)
 144{
 145        struct ncp_request_reply *req;
 146
 147        ncp_invalidate_conn(server);
 148        del_timer(&server->timeout_tm);
 149        while (!list_empty(&server->tx.requests)) {
 150                req = list_entry(server->tx.requests.next, struct ncp_request_reply, req);
 151                
 152                list_del_init(&req->req);
 153                ncp_finish_request(server, req, -EIO);
 154        }
 155        req = server->rcv.creq;
 156        if (req) {
 157                server->rcv.creq = NULL;
 158                ncp_finish_request(server, req, -EIO);
 159                server->rcv.ptr = NULL;
 160                server->rcv.state = 0;
 161        }
 162        req = server->tx.creq;
 163        if (req) {
 164                server->tx.creq = NULL;
 165                ncp_finish_request(server, req, -EIO);
 166        }
 167}
 168
 169static inline int get_conn_number(struct ncp_reply_header *rp)
 170{
 171        return rp->conn_low | (rp->conn_high << 8);
 172}
 173
 174static inline void __ncp_abort_request(struct ncp_server *server, struct ncp_request_reply *req, int err)
 175{
 176        /* If req is done, we got signal, but we also received answer... */
 177        switch (req->status) {
 178                case RQ_IDLE:
 179                case RQ_DONE:
 180                        break;
 181                case RQ_QUEUED:
 182                        list_del_init(&req->req);
 183                        ncp_finish_request(server, req, err);
 184                        break;
 185                case RQ_INPROGRESS:
 186                        req->status = RQ_ABANDONED;
 187                        break;
 188                case RQ_ABANDONED:
 189                        break;
 190        }
 191}
 192
 193static inline void ncp_abort_request(struct ncp_server *server, struct ncp_request_reply *req, int err)
 194{
 195        mutex_lock(&server->rcv.creq_mutex);
 196        __ncp_abort_request(server, req, err);
 197        mutex_unlock(&server->rcv.creq_mutex);
 198}
 199
 200static inline void __ncptcp_abort(struct ncp_server *server)
 201{
 202        __abort_ncp_connection(server);
 203}
 204
 205static int ncpdgram_send(struct socket *sock, struct ncp_request_reply *req)
 206{
 207        struct kvec vec[3];
 208        /* sock_sendmsg updates iov pointers for us :-( */
 209        memcpy(vec, req->tx_ciov, req->tx_iovlen * sizeof(vec[0]));
 210        return do_send(sock, vec, req->tx_iovlen,
 211                       req->tx_totallen, MSG_DONTWAIT);
 212}
 213
 214static void __ncptcp_try_send(struct ncp_server *server)
 215{
 216        struct ncp_request_reply *rq;
 217        struct kvec *iov;
 218        struct kvec iovc[3];
 219        int result;
 220
 221        rq = server->tx.creq;
 222        if (!rq)
 223                return;
 224
 225        /* sock_sendmsg updates iov pointers for us :-( */
 226        memcpy(iovc, rq->tx_ciov, rq->tx_iovlen * sizeof(iov[0]));
 227        result = do_send(server->ncp_sock, iovc, rq->tx_iovlen,
 228                         rq->tx_totallen, MSG_NOSIGNAL | MSG_DONTWAIT);
 229
 230        if (result == -EAGAIN)
 231                return;
 232
 233        if (result < 0) {
 234                printk(KERN_ERR "ncpfs: tcp: Send failed: %d\n", result);
 235                __ncp_abort_request(server, rq, result);
 236                return;
 237        }
 238        if (result >= rq->tx_totallen) {
 239                server->rcv.creq = rq;
 240                server->tx.creq = NULL;
 241                return;
 242        }
 243        rq->tx_totallen -= result;
 244        iov = rq->tx_ciov;
 245        while (iov->iov_len <= result) {
 246                result -= iov->iov_len;
 247                iov++;
 248                rq->tx_iovlen--;
 249        }
 250        iov->iov_base += result;
 251        iov->iov_len -= result;
 252        rq->tx_ciov = iov;
 253}
 254
 255static inline void ncp_init_header(struct ncp_server *server, struct ncp_request_reply *req, struct ncp_request_header *h)
 256{
 257        req->status = RQ_INPROGRESS;
 258        h->conn_low = server->connection;
 259        h->conn_high = server->connection >> 8;
 260        h->sequence = ++server->sequence;
 261}
 262        
 263static void ncpdgram_start_request(struct ncp_server *server, struct ncp_request_reply *req)
 264{
 265        size_t signlen;
 266        struct ncp_request_header* h;
 267        
 268        req->tx_ciov = req->tx_iov + 1;
 269
 270        h = req->tx_iov[1].iov_base;
 271        ncp_init_header(server, req, h);
 272        signlen = sign_packet(server, req->tx_iov[1].iov_base + sizeof(struct ncp_request_header) - 1, 
 273                        req->tx_iov[1].iov_len - sizeof(struct ncp_request_header) + 1,
 274                        cpu_to_le32(req->tx_totallen), req->sign);
 275        if (signlen) {
 276                req->tx_ciov[1].iov_base = req->sign;
 277                req->tx_ciov[1].iov_len = signlen;
 278                req->tx_iovlen += 1;
 279                req->tx_totallen += signlen;
 280        }
 281        server->rcv.creq = req;
 282        server->timeout_last = server->m.time_out;
 283        server->timeout_retries = server->m.retry_count;
 284        ncpdgram_send(server->ncp_sock, req);
 285        mod_timer(&server->timeout_tm, jiffies + server->m.time_out);
 286}
 287
 288#define NCP_TCP_XMIT_MAGIC      (0x446D6454)
 289#define NCP_TCP_XMIT_VERSION    (1)
 290#define NCP_TCP_RCVD_MAGIC      (0x744E6350)
 291
 292static void ncptcp_start_request(struct ncp_server *server, struct ncp_request_reply *req)
 293{
 294        size_t signlen;
 295        struct ncp_request_header* h;
 296
 297        req->tx_ciov = req->tx_iov;
 298        h = req->tx_iov[1].iov_base;
 299        ncp_init_header(server, req, h);
 300        signlen = sign_packet(server, req->tx_iov[1].iov_base + sizeof(struct ncp_request_header) - 1,
 301                        req->tx_iov[1].iov_len - sizeof(struct ncp_request_header) + 1,
 302                        cpu_to_be32(req->tx_totallen + 24), req->sign + 4) + 16;
 303
 304        req->sign[0] = htonl(NCP_TCP_XMIT_MAGIC);
 305        req->sign[1] = htonl(req->tx_totallen + signlen);
 306        req->sign[2] = htonl(NCP_TCP_XMIT_VERSION);
 307        req->sign[3] = htonl(req->datalen + 8);
 308        req->tx_iov[0].iov_base = req->sign;
 309        req->tx_iov[0].iov_len = signlen;
 310        req->tx_iovlen += 1;
 311        req->tx_totallen += signlen;
 312
 313        server->tx.creq = req;
 314        __ncptcp_try_send(server);
 315}
 316
 317static inline void __ncp_start_request(struct ncp_server *server, struct ncp_request_reply *req)
 318{
 319        /* we copy the data so that we do not depend on the caller
 320           staying alive */
 321        memcpy(server->txbuf, req->tx_iov[1].iov_base, req->tx_iov[1].iov_len);
 322        req->tx_iov[1].iov_base = server->txbuf;
 323
 324        if (server->ncp_sock->type == SOCK_STREAM)
 325                ncptcp_start_request(server, req);
 326        else
 327                ncpdgram_start_request(server, req);
 328}
 329
 330static int ncp_add_request(struct ncp_server *server, struct ncp_request_reply *req)
 331{
 332        mutex_lock(&server->rcv.creq_mutex);
 333        if (!ncp_conn_valid(server)) {
 334                mutex_unlock(&server->rcv.creq_mutex);
 335                printk(KERN_ERR "ncpfs: tcp: Server died\n");
 336                return -EIO;
 337        }
 338        ncp_req_get(req);
 339        if (server->tx.creq || server->rcv.creq) {
 340                req->status = RQ_QUEUED;
 341                list_add_tail(&req->req, &server->tx.requests);
 342                mutex_unlock(&server->rcv.creq_mutex);
 343                return 0;
 344        }
 345        __ncp_start_request(server, req);
 346        mutex_unlock(&server->rcv.creq_mutex);
 347        return 0;
 348}
 349
 350static void __ncp_next_request(struct ncp_server *server)
 351{
 352        struct ncp_request_reply *req;
 353
 354        server->rcv.creq = NULL;
 355        if (list_empty(&server->tx.requests)) {
 356                return;
 357        }
 358        req = list_entry(server->tx.requests.next, struct ncp_request_reply, req);
 359        list_del_init(&req->req);
 360        __ncp_start_request(server, req);
 361}
 362
 363static void info_server(struct ncp_server *server, unsigned int id, const void * data, size_t len)
 364{
 365        if (server->info_sock) {
 366                struct kvec iov[2];
 367                __be32 hdr[2];
 368        
 369                hdr[0] = cpu_to_be32(len + 8);
 370                hdr[1] = cpu_to_be32(id);
 371        
 372                iov[0].iov_base = hdr;
 373                iov[0].iov_len = 8;
 374                iov[1].iov_base = (void *) data;
 375                iov[1].iov_len = len;
 376
 377                do_send(server->info_sock, iov, 2, len + 8, MSG_NOSIGNAL);
 378        }
 379}
 380
 381void ncpdgram_rcv_proc(struct work_struct *work)
 382{
 383        struct ncp_server *server =
 384                container_of(work, struct ncp_server, rcv.tq);
 385        struct socket* sock;
 386        
 387        sock = server->ncp_sock;
 388        
 389        while (1) {
 390                struct ncp_reply_header reply;
 391                int result;
 392
 393                result = _recv(sock, &reply, sizeof(reply), MSG_PEEK | MSG_DONTWAIT);
 394                if (result < 0) {
 395                        break;
 396                }
 397                if (result >= sizeof(reply)) {
 398                        struct ncp_request_reply *req;
 399        
 400                        if (reply.type == NCP_WATCHDOG) {
 401                                unsigned char buf[10];
 402
 403                                if (server->connection != get_conn_number(&reply)) {
 404                                        goto drop;
 405                                }
 406                                result = _recv(sock, buf, sizeof(buf), MSG_DONTWAIT);
 407                                if (result < 0) {
 408                                        DPRINTK("recv failed with %d\n", result);
 409                                        continue;
 410                                }
 411                                if (result < 10) {
 412                                        DPRINTK("too short (%u) watchdog packet\n", result);
 413                                        continue;
 414                                }
 415                                if (buf[9] != '?') {
 416                                        DPRINTK("bad signature (%02X) in watchdog packet\n", buf[9]);
 417                                        continue;
 418                                }
 419                                buf[9] = 'Y';
 420                                _send(sock, buf, sizeof(buf));
 421                                continue;
 422                        }
 423                        if (reply.type != NCP_POSITIVE_ACK && reply.type != NCP_REPLY) {
 424                                result = _recv(sock, server->unexpected_packet.data, sizeof(server->unexpected_packet.data), MSG_DONTWAIT);
 425                                if (result < 0) {
 426                                        continue;
 427                                }
 428                                info_server(server, 0, server->unexpected_packet.data, result);
 429                                continue;
 430                        }
 431                        mutex_lock(&server->rcv.creq_mutex);
 432                        req = server->rcv.creq;
 433                        if (req && (req->tx_type == NCP_ALLOC_SLOT_REQUEST || (server->sequence == reply.sequence && 
 434                                        server->connection == get_conn_number(&reply)))) {
 435                                if (reply.type == NCP_POSITIVE_ACK) {
 436                                        server->timeout_retries = server->m.retry_count;
 437                                        server->timeout_last = NCP_MAX_RPC_TIMEOUT;
 438                                        mod_timer(&server->timeout_tm, jiffies + NCP_MAX_RPC_TIMEOUT);
 439                                } else if (reply.type == NCP_REPLY) {
 440                                        result = _recv(sock, server->rxbuf, req->datalen, MSG_DONTWAIT);
 441#ifdef CONFIG_NCPFS_PACKET_SIGNING
 442                                        if (result >= 0 && server->sign_active && req->tx_type != NCP_DEALLOC_SLOT_REQUEST) {
 443                                                if (result < 8 + 8) {
 444                                                        result = -EIO;
 445                                                } else {
 446                                                        unsigned int hdrl;
 447                                                        
 448                                                        result -= 8;
 449                                                        hdrl = sock->sk->sk_family == AF_INET ? 8 : 6;
 450                                                        if (sign_verify_reply(server, server->rxbuf + hdrl, result - hdrl, cpu_to_le32(result), server->rxbuf + result)) {
 451                                                                printk(KERN_INFO "ncpfs: Signature violation\n");
 452                                                                result = -EIO;
 453                                                        }
 454                                                }
 455                                        }
 456#endif
 457                                        del_timer(&server->timeout_tm);
 458                                        server->rcv.creq = NULL;
 459                                        ncp_finish_request(server, req, result);
 460                                        __ncp_next_request(server);
 461                                        mutex_unlock(&server->rcv.creq_mutex);
 462                                        continue;
 463                                }
 464                        }
 465                        mutex_unlock(&server->rcv.creq_mutex);
 466                }
 467drop:;          
 468                _recv(sock, &reply, sizeof(reply), MSG_DONTWAIT);
 469        }
 470}
 471
 472static void __ncpdgram_timeout_proc(struct ncp_server *server)
 473{
 474        /* If timer is pending, we are processing another request... */
 475        if (!timer_pending(&server->timeout_tm)) {
 476                struct ncp_request_reply* req;
 477                
 478                req = server->rcv.creq;
 479                if (req) {
 480                        int timeout;
 481                        
 482                        if (server->m.flags & NCP_MOUNT_SOFT) {
 483                                if (server->timeout_retries-- == 0) {
 484                                        __ncp_abort_request(server, req, -ETIMEDOUT);
 485                                        return;
 486                                }
 487                        }
 488                        /* Ignore errors */
 489                        ncpdgram_send(server->ncp_sock, req);
 490                        timeout = server->timeout_last << 1;
 491                        if (timeout > NCP_MAX_RPC_TIMEOUT) {
 492                                timeout = NCP_MAX_RPC_TIMEOUT;
 493                        }
 494                        server->timeout_last = timeout;
 495                        mod_timer(&server->timeout_tm, jiffies + timeout);
 496                }
 497        }
 498}
 499
 500void ncpdgram_timeout_proc(struct work_struct *work)
 501{
 502        struct ncp_server *server =
 503                container_of(work, struct ncp_server, timeout_tq);
 504        mutex_lock(&server->rcv.creq_mutex);
 505        __ncpdgram_timeout_proc(server);
 506        mutex_unlock(&server->rcv.creq_mutex);
 507}
 508
 509static int do_tcp_rcv(struct ncp_server *server, void *buffer, size_t len)
 510{
 511        int result;
 512        
 513        if (buffer) {
 514                result = _recv(server->ncp_sock, buffer, len, MSG_DONTWAIT);
 515        } else {
 516                static unsigned char dummy[1024];
 517                        
 518                if (len > sizeof(dummy)) {
 519                        len = sizeof(dummy);
 520                }
 521                result = _recv(server->ncp_sock, dummy, len, MSG_DONTWAIT);
 522        }
 523        if (result < 0) {
 524                return result;
 525        }
 526        if (result > len) {
 527                printk(KERN_ERR "ncpfs: tcp: bug in recvmsg (%u > %Zu)\n", result, len);
 528                return -EIO;                    
 529        }
 530        return result;
 531}       
 532
 533static int __ncptcp_rcv_proc(struct ncp_server *server)
 534{
 535        /* We have to check the result, so store the complete header */
 536        while (1) {
 537                int result;
 538                struct ncp_request_reply *req;
 539                int datalen;
 540                int type;
 541
 542                while (server->rcv.len) {
 543                        result = do_tcp_rcv(server, server->rcv.ptr, server->rcv.len);
 544                        if (result == -EAGAIN) {
 545                                return 0;
 546                        }
 547                        if (result <= 0) {
 548                                req = server->rcv.creq;
 549                                if (req) {
 550                                        __ncp_abort_request(server, req, -EIO);
 551                                } else {
 552                                        __ncptcp_abort(server);
 553                                }
 554                                if (result < 0) {
 555                                        printk(KERN_ERR "ncpfs: tcp: error in recvmsg: %d\n", result);
 556                                } else {
 557                                        DPRINTK(KERN_ERR "ncpfs: tcp: EOF\n");
 558                                }
 559                                return -EIO;
 560                        }
 561                        if (server->rcv.ptr) {
 562                                server->rcv.ptr += result;
 563                        }
 564                        server->rcv.len -= result;
 565                }
 566                switch (server->rcv.state) {
 567                        case 0:
 568                                if (server->rcv.buf.magic != htonl(NCP_TCP_RCVD_MAGIC)) {
 569                                        printk(KERN_ERR "ncpfs: tcp: Unexpected reply type %08X\n", ntohl(server->rcv.buf.magic));
 570                                        __ncptcp_abort(server);
 571                                        return -EIO;
 572                                }
 573                                datalen = ntohl(server->rcv.buf.len) & 0x0FFFFFFF;
 574                                if (datalen < 10) {
 575                                        printk(KERN_ERR "ncpfs: tcp: Unexpected reply len %d\n", datalen);
 576                                        __ncptcp_abort(server);
 577                                        return -EIO;
 578                                }
 579#ifdef CONFIG_NCPFS_PACKET_SIGNING                              
 580                                if (server->sign_active) {
 581                                        if (datalen < 18) {
 582                                                printk(KERN_ERR "ncpfs: tcp: Unexpected reply len %d\n", datalen);
 583                                                __ncptcp_abort(server);
 584                                                return -EIO;
 585                                        }
 586                                        server->rcv.buf.len = datalen - 8;
 587                                        server->rcv.ptr = (unsigned char*)&server->rcv.buf.p1;
 588                                        server->rcv.len = 8;
 589                                        server->rcv.state = 4;
 590                                        break;
 591                                }
 592#endif                          
 593                                type = ntohs(server->rcv.buf.type);
 594#ifdef CONFIG_NCPFS_PACKET_SIGNING                              
 595cont:;                          
 596#endif
 597                                if (type != NCP_REPLY) {
 598                                        if (datalen - 8 <= sizeof(server->unexpected_packet.data)) {
 599                                                *(__u16*)(server->unexpected_packet.data) = htons(type);
 600                                                server->unexpected_packet.len = datalen - 8;
 601
 602                                                server->rcv.state = 5;
 603                                                server->rcv.ptr = server->unexpected_packet.data + 2;
 604                                                server->rcv.len = datalen - 10;
 605                                                break;
 606                                        }                                       
 607                                        DPRINTK("ncpfs: tcp: Unexpected NCP type %02X\n", type);
 608skipdata2:;
 609                                        server->rcv.state = 2;
 610skipdata:;
 611                                        server->rcv.ptr = NULL;
 612                                        server->rcv.len = datalen - 10;
 613                                        break;
 614                                }
 615                                req = server->rcv.creq;
 616                                if (!req) {
 617                                        DPRINTK(KERN_ERR "ncpfs: Reply without appropriate request\n");
 618                                        goto skipdata2;
 619                                }
 620                                if (datalen > req->datalen + 8) {
 621                                        printk(KERN_ERR "ncpfs: tcp: Unexpected reply len %d (expected at most %Zd)\n", datalen, req->datalen + 8);
 622                                        server->rcv.state = 3;
 623                                        goto skipdata;
 624                                }
 625                                req->datalen = datalen - 8;
 626                                ((struct ncp_reply_header*)server->rxbuf)->type = NCP_REPLY;
 627                                server->rcv.ptr = server->rxbuf + 2;
 628                                server->rcv.len = datalen - 10;
 629                                server->rcv.state = 1;
 630                                break;
 631#ifdef CONFIG_NCPFS_PACKET_SIGNING                              
 632                        case 4:
 633                                datalen = server->rcv.buf.len;
 634                                type = ntohs(server->rcv.buf.type2);
 635                                goto cont;
 636#endif
 637                        case 1:
 638                                req = server->rcv.creq;
 639                                if (req->tx_type != NCP_ALLOC_SLOT_REQUEST) {
 640                                        if (((struct ncp_reply_header*)server->rxbuf)->sequence != server->sequence) {
 641                                                printk(KERN_ERR "ncpfs: tcp: Bad sequence number\n");
 642                                                __ncp_abort_request(server, req, -EIO);
 643                                                return -EIO;
 644                                        }
 645                                        if ((((struct ncp_reply_header*)server->rxbuf)->conn_low | (((struct ncp_reply_header*)server->rxbuf)->conn_high << 8)) != server->connection) {
 646                                                printk(KERN_ERR "ncpfs: tcp: Connection number mismatch\n");
 647                                                __ncp_abort_request(server, req, -EIO);
 648                                                return -EIO;
 649                                        }
 650                                }
 651#ifdef CONFIG_NCPFS_PACKET_SIGNING                              
 652                                if (server->sign_active && req->tx_type != NCP_DEALLOC_SLOT_REQUEST) {
 653                                        if (sign_verify_reply(server, server->rxbuf + 6, req->datalen - 6, cpu_to_be32(req->datalen + 16), &server->rcv.buf.type)) {
 654                                                printk(KERN_ERR "ncpfs: tcp: Signature violation\n");
 655                                                __ncp_abort_request(server, req, -EIO);
 656                                                return -EIO;
 657                                        }
 658                                }
 659#endif                          
 660                                ncp_finish_request(server, req, req->datalen);
 661                        nextreq:;
 662                                __ncp_next_request(server);
 663                        case 2:
 664                        next:;
 665                                server->rcv.ptr = (unsigned char*)&server->rcv.buf;
 666                                server->rcv.len = 10;
 667                                server->rcv.state = 0;
 668                                break;
 669                        case 3:
 670                                ncp_finish_request(server, server->rcv.creq, -EIO);
 671                                goto nextreq;
 672                        case 5:
 673                                info_server(server, 0, server->unexpected_packet.data, server->unexpected_packet.len);
 674                                goto next;
 675                }
 676        }
 677}
 678
 679void ncp_tcp_rcv_proc(struct work_struct *work)
 680{
 681        struct ncp_server *server =
 682                container_of(work, struct ncp_server, rcv.tq);
 683
 684        mutex_lock(&server->rcv.creq_mutex);
 685        __ncptcp_rcv_proc(server);
 686        mutex_unlock(&server->rcv.creq_mutex);
 687}
 688
 689void ncp_tcp_tx_proc(struct work_struct *work)
 690{
 691        struct ncp_server *server =
 692                container_of(work, struct ncp_server, tx.tq);
 693        
 694        mutex_lock(&server->rcv.creq_mutex);
 695        __ncptcp_try_send(server);
 696        mutex_unlock(&server->rcv.creq_mutex);
 697}
 698
 699static int do_ncp_rpc_call(struct ncp_server *server, int size,
 700                unsigned char* reply_buf, int max_reply_size)
 701{
 702        int result;
 703        struct ncp_request_reply *req;
 704
 705        req = ncp_alloc_req();
 706        if (!req)
 707                return -ENOMEM;
 708
 709        req->reply_buf = reply_buf;
 710        req->datalen = max_reply_size;
 711        req->tx_iov[1].iov_base = server->packet;
 712        req->tx_iov[1].iov_len = size;
 713        req->tx_iovlen = 1;
 714        req->tx_totallen = size;
 715        req->tx_type = *(u_int16_t*)server->packet;
 716
 717        result = ncp_add_request(server, req);
 718        if (result < 0)
 719                goto out;
 720
 721        if (wait_event_interruptible(req->wq, req->status == RQ_DONE)) {
 722                ncp_abort_request(server, req, -EINTR);
 723                result = -EINTR;
 724                goto out;
 725        }
 726
 727        result = req->result;
 728
 729out:
 730        ncp_req_put(req);
 731
 732        return result;
 733}
 734
 735/*
 736 * We need the server to be locked here, so check!
 737 */
 738
 739static int ncp_do_request(struct ncp_server *server, int size,
 740                void* reply, int max_reply_size)
 741{
 742        int result;
 743
 744        if (server->lock == 0) {
 745                printk(KERN_ERR "ncpfs: Server not locked!\n");
 746                return -EIO;
 747        }
 748        if (!ncp_conn_valid(server)) {
 749                return -EIO;
 750        }
 751        {
 752                sigset_t old_set;
 753                unsigned long mask, flags;
 754
 755                spin_lock_irqsave(&current->sighand->siglock, flags);
 756                old_set = current->blocked;
 757                if (current->flags & PF_EXITING)
 758                        mask = 0;
 759                else
 760                        mask = sigmask(SIGKILL);
 761                if (server->m.flags & NCP_MOUNT_INTR) {
 762                        /* FIXME: This doesn't seem right at all.  So, like,
 763                           we can't handle SIGINT and get whatever to stop?
 764                           What if we've blocked it ourselves?  What about
 765                           alarms?  Why, in fact, are we mucking with the
 766                           sigmask at all? -- r~ */
 767                        if (current->sighand->action[SIGINT - 1].sa.sa_handler == SIG_DFL)
 768                                mask |= sigmask(SIGINT);
 769                        if (current->sighand->action[SIGQUIT - 1].sa.sa_handler == SIG_DFL)
 770                                mask |= sigmask(SIGQUIT);
 771                }
 772                siginitsetinv(&current->blocked, mask);
 773                recalc_sigpending();
 774                spin_unlock_irqrestore(&current->sighand->siglock, flags);
 775                
 776                result = do_ncp_rpc_call(server, size, reply, max_reply_size);
 777
 778                spin_lock_irqsave(&current->sighand->siglock, flags);
 779                current->blocked = old_set;
 780                recalc_sigpending();
 781                spin_unlock_irqrestore(&current->sighand->siglock, flags);
 782        }
 783
 784        DDPRINTK("do_ncp_rpc_call returned %d\n", result);
 785
 786        return result;
 787}
 788
 789/* ncp_do_request assures that at least a complete reply header is
 790 * received. It assumes that server->current_size contains the ncp
 791 * request size
 792 */
 793int ncp_request2(struct ncp_server *server, int function, 
 794                void* rpl, int size)
 795{
 796        struct ncp_request_header *h;
 797        struct ncp_reply_header* reply = rpl;
 798        int result;
 799
 800        h = (struct ncp_request_header *) (server->packet);
 801        if (server->has_subfunction != 0) {
 802                *(__u16 *) & (h->data[0]) = htons(server->current_size - sizeof(*h) - 2);
 803        }
 804        h->type = NCP_REQUEST;
 805        /*
 806         * The server shouldn't know or care what task is making a
 807         * request, so we always use the same task number.
 808         */
 809        h->task = 2; /* (current->pid) & 0xff; */
 810        h->function = function;
 811
 812        result = ncp_do_request(server, server->current_size, reply, size);
 813        if (result < 0) {
 814                DPRINTK("ncp_request_error: %d\n", result);
 815                goto out;
 816        }
 817        server->completion = reply->completion_code;
 818        server->conn_status = reply->connection_state;
 819        server->reply_size = result;
 820        server->ncp_reply_size = result - sizeof(struct ncp_reply_header);
 821
 822        result = reply->completion_code;
 823
 824        if (result != 0)
 825                PPRINTK("ncp_request: completion code=%x\n", result);
 826out:
 827        return result;
 828}
 829
 830int ncp_connect(struct ncp_server *server)
 831{
 832        struct ncp_request_header *h;
 833        int result;
 834
 835        server->connection = 0xFFFF;
 836        server->sequence = 255;
 837
 838        h = (struct ncp_request_header *) (server->packet);
 839        h->type = NCP_ALLOC_SLOT_REQUEST;
 840        h->task         = 2; /* see above */
 841        h->function     = 0;
 842
 843        result = ncp_do_request(server, sizeof(*h), server->packet, server->packet_size);
 844        if (result < 0)
 845                goto out;
 846        server->connection = h->conn_low + (h->conn_high * 256);
 847        result = 0;
 848out:
 849        return result;
 850}
 851
 852int ncp_disconnect(struct ncp_server *server)
 853{
 854        struct ncp_request_header *h;
 855
 856        h = (struct ncp_request_header *) (server->packet);
 857        h->type = NCP_DEALLOC_SLOT_REQUEST;
 858        h->task         = 2; /* see above */
 859        h->function     = 0;
 860
 861        return ncp_do_request(server, sizeof(*h), server->packet, server->packet_size);
 862}
 863
 864void ncp_lock_server(struct ncp_server *server)
 865{
 866        mutex_lock(&server->mutex);
 867        if (server->lock)
 868                printk(KERN_WARNING "ncp_lock_server: was locked!\n");
 869        server->lock = 1;
 870}
 871
 872void ncp_unlock_server(struct ncp_server *server)
 873{
 874        if (!server->lock) {
 875                printk(KERN_WARNING "ncp_unlock_server: was not locked!\n");
 876                return;
 877        }
 878        server->lock = 0;
 879        mutex_unlock(&server->mutex);
 880}
 881