ckcnet.c

KERMIT工具 这在办公室下载不了,很多人都没有载不到.

                          "TCP ck_linger can't set SO_LINGER",
                          ck_errstr(),
                          errno
                          );
                    tcp_linger = get_linger_opt16.s_onoff;
                    tcp_linger_tmo = get_linger_opt16.s_linger;
                } else {
                    debug(F101,
                          "TCP ck_linger new SO_LINGER","",
                          set_linger_opt16.s_onoff);
                    tcp_linger = set_linger_opt16.s_onoff;
                    tcp_linger_tmo = set_linger_opt16.s_linger;
                    return 1;
                }
            } else {
                debug(F101,"TCP ck_linger SO_LINGER unchanged","",
                       get_linger_opt16.s_onoff);
                tcp_linger = get_linger_opt16.s_onoff;
                tcp_linger_tmo = get_linger_opt16.s_linger;
                return 1;
            }
            return(0);
        }
#endif /* OS2 */
        debug(F111,"TCP ck_linger error: SO_LINGER","len",x);
        debug(F111,"TCP ck_linger SO_LINGER",
              "expected len",sizeof(get_linger_opt));
        debug(F111,"TCP ck_linger SO_LINGER","linger_opt.l_onoff",
              get_linger_opt.l_onoff);
        debug(F111,"TCP linger SO_LINGER","linger_opt.l_linger",
               get_linger_opt.l_linger);
    } else if (get_linger_opt.l_onoff != onoff ||
               get_linger_opt.l_linger != timo) {
        set_linger_opt.l_onoff  = onoff;
        set_linger_opt.l_linger = timo;
        if (setsockopt(sock,
                       SOL_SOCKET,
                       SO_LINGER,
                       (char *)&set_linger_opt,
                       sizeof(set_linger_opt))) {
            debug(F111,"TCP ck_linger can't set SO_LINGER",ck_errstr(),errno);
            tcp_linger = get_linger_opt.l_onoff;
            tcp_linger_tmo = get_linger_opt.l_linger;
         } else {
             debug(F101,
                   "TCP ck_linger new SO_LINGER",
                   "",
                   set_linger_opt.l_onoff
                   );
             tcp_linger = set_linger_opt.l_onoff;
             tcp_linger_tmo = set_linger_opt.l_linger;
             return 1;
         }
    } else {
        debug(F101,"TCP ck_linger SO_LINGER unchanged","",
              get_linger_opt.l_onoff);
        tcp_linger = get_linger_opt.l_onoff;
        tcp_linger_tmo = get_linger_opt.l_linger;
        return 1;
    }
#else
    debug(F100,"TCP ck_linger SO_LINGER not defined","",0);
#endif /* SO_LINGER */
#else
    debug(F100,"TCP ck_linger SO_SOCKET not defined","",0);
#endif /* SOL_SOCKET */
    return(0);
}

int
sendbuf(sock,size) int sock; int size; {
/*
  The following, from William Bader, allows changing of socket buffer sizes,
  in case that might affect performance.

  Modified by Jeff Altman to be generally useful.
*/
#ifdef SOL_SOCKET
#ifdef SO_SNDBUF
    int i, j;
    SOCKOPT_T x;

#ifdef IKSD
    if (!inserver)
#endif /* IKSD */
      if (sock == -1 ||
        nettype != NET_TCPA && nettype != NET_TCPB && nettype != NET_SSH
                || ttmdm >= 0) {
        tcp_sendbuf = size;
        return 1;
    }
    x = sizeof(i);
    if (getsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&i, &x)) {
        debug(F111,"TCP sendbuf can't get SO_SNDBUF",ck_errstr(),errno);
    } else if (x != sizeof(i)) {
#ifdef OS2
        short i16,j16;
        if (x == sizeof(i16)) {
            debug(F111,"TCP sendbuf warning: SO_SNDBUF","len is 16-bit",x);
            if (getsockopt(sock,
                           SOL_SOCKET, SO_SNDBUF,
                           (char *)&i16, &x)
                ) {
                debug(F111,"TCP sendbuf can't get SO_SNDBUF",
                      ck_errstr(),errno);
            } else if (size <= 0) {
                tcp_sendbuf = i16;
                debug(F101,"TCP sendbuf SO_SNDBUF retrieved","",i16);
                return 1;
            } else if (i16 != size) {
                j16 = size;
                if (setsockopt(sock,
                               SOL_SOCKET,
                               SO_SNDBUF,
                               (char *)&j16,
                               sizeof(j16))
                    ) {
                    debug(F111,"TCP sendbuf can't set SO_SNDBUF",
                          ck_errstr(),errno);
                } else {
                    debug(F101,"TCP sendbuf old SO_SNDBUF","",i16);
                    debug(F101,"TCP sendbuf new SO_SNDBUF","",j16);
                    tcp_sendbuf = size;
                    return 1;
                }
            } else {
                debug(F101,"TCP sendbuf SO_SNDBUF unchanged","",i16);
                tcp_sendbuf = size;
                return 1;
            }
            return(0);
        }
#endif /* OS2 */
        debug(F111,"TCP sendbuf error: SO_SNDBUF","len",x);
        debug(F111,"TCP sendbuf SO_SNDBUF","expected len",sizeof(i));
        debug(F111,"TCP sendbuf SO_SNDBUF","i",i);
    } else if (size <= 0) {
        tcp_sendbuf = i;
        debug(F101,"TCP sendbuf SO_SNDBUF retrieved","",i);
        return 1;
    } else if (i != size) {
        j = size;
        if (setsockopt(sock, SOL_SOCKET, SO_SNDBUF, (char *)&j, sizeof(j))) {
            debug(F111,"TCP sendbuf can't set SO_SNDBUF",ck_errstr(),errno);
            tcp_sendbuf = i;
        } else {
            debug(F101,"TCP sendbuf old SO_SNDBUF","",i);
            debug(F101,"TCP sendbuf new SO_SNDBUF","",j);
            tcp_sendbuf = size;
            return 1;
        }
    } else {
        debug(F101,"TCP sendbuf SO_SNDBUF unchanged","",i);
        tcp_sendbuf = size;
        return 1;
    }
#else
    debug(F100,"TCP sendbuf SO_SNDBUF not defined","",0);
#endif /* SO_SNDBUF */
#else
    debug(F100,"TCP sendbuf SO_SOCKET not defined","",0);
#endif /* SOL_SOCKET */
    return(0);
}

int
recvbuf(sock,size) int sock; int size; {
/*
  The following, from William Bader, allows changing of socket buffer sizes,
  in case that might affect performance.

  Modified by Jeff Altman to be generally useful.
*/
#ifdef SOL_SOCKET
#ifdef SO_RCVBUF
    int i, j;
    SOCKOPT_T x;

#ifdef IKSD
    if (!inserver)
#endif /* IKSD */
      if (sock == -1 ||
	  nettype != NET_TCPA && nettype != NET_TCPB &&
	  nettype != NET_SSH || ttmdm >= 0) {
        tcp_recvbuf = size;
        return(1);
    }
    x = sizeof(i);
    if (getsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&i, &x)) {
        debug(F111,"TCP recvbuf can't get SO_RCVBUF",ck_errstr(),errno);
    } else if (x != sizeof(i)) {
#ifdef OS2
        short i16,j16;
        if ( x == sizeof(i16) ) {
            debug(F111,"TCP recvbuf warning: SO_RCVBUF","len is 16-bit",x);
            if (getsockopt(sock,
                           SOL_SOCKET, SO_RCVBUF,
                           (char *)&i16, &x)
                ) {
                debug(F111,"TCP recvbuf can't get SO_RCVBUF",
                      ck_errstr(),errno);
            } else if (size <= 0) {
                tcp_recvbuf = i16;
                debug(F101,"TCP recvbuf SO_RCVBUF retrieved","",i16);
                return 1;
            } else if (i16 != size) {
                j16 = size;
                if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&j16,
                               sizeof(j16))) {
                    debug(F111,"TCP recvbuf can' set SO_RCVBUF",
                          ck_errstr(),errno);
                } else {
                    debug(F101,"TCP recvbuf old SO_RCVBUF","",i16);
                    debug(F101,"TCP recvbuf new SO_RCVBUF","",j16);
                    tcp_recvbuf = size;
                    return 1;
                }
            } else {
                debug(F101,"TCP recvbuf SO_RCVBUF unchanged","",i16);
                tcp_recvbuf = size;
                return 1;
            }
            return(0);
        }
#endif /* OS2 */
        debug(F111,"TCP recvbuf error: SO_RCVBUF","len",x);
        debug(F111,"TCP recvbuf SO_RCVBUF","expected len",sizeof(i));
        debug(F111,"TCP recvbuf SO_RCVBUF","i",i);
    } else if (size <= 0) {
        tcp_recvbuf = i;
        debug(F101,"TCP recvbuf SO_RCVBUF retrieved","",i);
        return 1;
    } else if (i != size) {
        j = size;
        if (setsockopt(sock, SOL_SOCKET, SO_RCVBUF, (char *)&j, sizeof(j))) {
            debug(F111,"TCP recvbuf can't set SO_RCVBUF",ck_errstr(),errno);
            tcp_recvbuf = i;
        } else {
            debug(F101,"TCP recvbuf old SO_RCVBUF","",i);
            debug(F101,"TCP recvbuf new SO_RCVBUF","",j);
            tcp_recvbuf = size;
            return 1;
        }
    } else {
        debug(F101,"TCP recvbuf SO_RCVBUF unchanged","",i);
        tcp_recvbuf = size;
        return 1;
    }
#else
    debug(F100,"TCP recvbuf SO_RCVBUF not defined","",0);
#endif /* SO_RCVBUF */
#else
    debug(F100,"TCP recvbuf SO_SOCKET not defined","",0);
#endif /* SOL_SOCKET */
    return 0;
}

int
keepalive(sock,onoff) int sock; int onoff; {
#ifdef SOL_SOCKET
#ifdef SO_KEEPALIVE
    int get_keepalive_opt;
    int set_keepalive_opt;
    SOCKOPT_T x;

    debug(F111,"TCP keepalive","sock",sock);
    debug(F111,"TCP keepalive","nettype",nettype);
    debug(F111,"TCP keepalive","ttmdm",ttmdm);

#ifdef IKSD
    if (!inserver)
#endif /* IKSD */
      if (sock == -1 ||
        nettype != NET_TCPA && nettype != NET_TCPB && nettype != NET_SSH
                || ttmdm >= 0) {
        tcp_keepalive = onoff;
        return 1;
    }
    x = sizeof(get_keepalive_opt);
    if (getsockopt(sock,
                   SOL_SOCKET, SO_KEEPALIVE, (char *)&get_keepalive_opt, &x)) {
        debug(F111,"TCP keepalive can't get SO_KEEPALIVE",ck_errstr(),errno);
    } else if (x != sizeof(get_keepalive_opt)) {
#ifdef OS2
        short get_keepalive_opt16;
        short set_keepalive_opt16;
        if (x == sizeof(get_keepalive_opt16)) {
            debug(F111,"TCP keepalive warning: SO_KEEPALIVE",
                  "len is 16-bit",x);
            if (getsockopt(sock,
                           SOL_SOCKET, SO_KEEPALIVE,
                           (char *)&get_keepalive_opt16, &x)
                ) {
                debug(F111,
                      "TCP keepalive can't get SO_KEEPALIVE",
                      ck_errstr(),
                      errno
                      );
            } else if (get_keepalive_opt16 != onoff) {
                set_keepalive_opt16 = onoff;
                if (setsockopt(sock,
                               SOL_SOCKET,
                               SO_KEEPALIVE,
                               (char *)&set_keepalive_opt16,
                               sizeof(set_keepalive_opt16))
                    ) {
                    debug(F111,
                          "TCP keepalive can't clear SO_KEEPALIVE",
                          ck_errstr(),
                          errno
                          );
                    tcp_keepalive = get_keepalive_opt16;
                } else {
                    debug(F101,
                          "TCP keepalive new SO_KEEPALIVE","",
                          set_keepalive_opt16);
                    tcp_keepalive = set_keepalive_opt16;
                    return 1;
                }
            } else {
                debug(F101,"TCP keepalive SO_KEEPALIVE unchanged","",
                      get_keepalive_opt16);
                tcp_keepalive = onoff;
                return 1;
            }
            return(0);
        }
#endif /* OS2 */
        debug(F111,"TCP keepalive error: SO_KEEPALIVE","len",x);
        debug(F111,
              "TCP keepalive SO_KEEPALIVE",
              "expected len",
              sizeof(get_keepalive_opt)
              );
        debug(F111,
              "TCP keepalive SO_KEEPALIVE",
              "keepalive_opt",
              get_keepalive_opt
              );
    } else if (get_keepalive_opt != onoff) {
            set_keepalive_opt = onoff;
            if (setsockopt(sock,
                            SOL_SOCKET,
                            SO_KEEPALIVE,
                            (char *)&set_keepalive_opt,
                            sizeof(set_keepalive_opt))
                ) {
                debug(F111,
                      "TCP keepalive can't clear SO_KEEPALIVE",
                      ck_errstr(),
                      errno
                      );
                tcp_keepalive = get_keepalive_opt;
            } else {
                debug(F101,
                      "TCP keepalive new SO_KEEPALIVE",
                      "",
                      set_keepalive_opt
                      );
                tcp_keepalive = onoff;
                return 1;
            }
        } else {
            debug(F101,"TCP keepalive SO_KEEPALIVE unchanged",
                  "",
                  get_keepalive_opt
                  );
            tcp_keepalive = onoff;
            return 1;
    }
#else
    debug(F100,"TCP keepalive SO_KEEPALIVE not defined","",0);
#endif /* SO_KEEPALIVE */
#else
    debug(F100,"TCP keepalive SO_SOCKET not defined","",0);
#endif /* SOL_SOCKET */
    return(0);
}

int
dontroute(sock,onoff) int sock; int onoff; {
#ifdef SOL_SOCKET
#ifdef SO_DONTROUTE
    int get_dontroute_opt;
    int set_dontroute_opt;
    SOCKOPT_T x;

#ifdef IKSD
    if (!inserver)
#endif /* IKSD */
      if (sock == -1 ||
        nettype != NET_TCPA && nettype != NET_TCPB && nettype != NET_SSH
                || ttmdm >= 0) {
        tcp_dontroute = onoff;
        return 1;
    }
    x = sizeof(get_dontroute_opt);
    if (getsockopt(sock,
                   SOL_SOCKET, SO_DONTROUTE, (char *)&get_dontroute_opt, &x)) {
        debug(F111,"TCP dontroute can't get SO_DONTROUTE",ck_errstr(),errno);
    } else if (x != sizeof(get_dontroute_opt)) {
#ifdef OS2
        short get_dontroute_opt16;
        short set_dontroute_opt16;
        if (x == sizeof(get_dontroute_opt16)) {
            debug(F111,"TCP dontroute warning: SO_DONTROUTE",
                  "len is 16-bit",x);
            if (getsockopt(sock,
                           SOL_SOCKET, SO_DONTROUTE,
                           (char *)&get_dontroute_opt16, &x)
                ) {
                debug(F111,
                      "TCP dontroute can't get SO_DONTROUTE",
                      ck_errstr(),
                      errno
                      );
            } else if (get_dontroute_opt16 != onoff) {
                set_dontroute_opt16 = onoff;
                if (setsockopt(sock,
                               SOL_SOCKET,
                               SO_DONTROUTE,
                               (char *)&set_dontroute_opt16,
                               sizeof(set_