checksrc: Fixed line length and comment indentation

#endif

  /*

** Here we process our command line, post errors (to the error screen),

** perform initializations and anything else we need to do before being able

** to accept calls into us. If we succeed, we return non-zero and the NetWare

** Loader will leave us up, otherwise we fail to load and get dumped.

   * Here we process our command line, post errors (to the error screen),

   * perform initializations and anything else we need to do before being able

   * to accept calls into us. If we succeed, we return non-zero and the NetWare

   * Loader will leave us up, otherwise we fail to load and get dumped.

   */

  gAllocTag = AllocateResourceTag(NLMHandle,

                                  "<library-name> memory allocations",

}

/*

** Here we clean up any resources we allocated. Resource tags is a big part

** of what we created, but NetWare doesn't ask us to free those.

 * Here we clean up any resources we allocated. Resource tags is a big part

 * of what we created, but NetWare doesn't ask us to free those.

 */

void _NonAppStop( void )

{

}

/*

** This function cannot be the first in the file for if the file is linked

** first, then the check-unload function's offset will be nlmname.nlm+0

** which is how to tell that there isn't one. When the check function is

** first in the linked objects, it is ambiguous. For this reason, we will

** put it inside this file after the stop function.

**

** Here we check to see if it's alright to ourselves to be unloaded. If not,

** we return a non-zero value. Right now, there isn't any reason not to allow

** it.

 * This function cannot be the first in the file for if the file is linked

 * first, then the check-unload function's offset will be nlmname.nlm+0

 * which is how to tell that there isn't one. When the check function is

 * first in the linked objects, it is ambiguous. For this reason, we will

 * put it inside this file after the stop function.

 *

 * Here we check to see if it's alright to ourselves to be unloaded. If not,

 * we return a non-zero value. Right now, there isn't any reason not to allow

 * it.

 */

int _NonAppCheckUnload( void )

{

  thread_data = (libthreaddata_t *) NULL;

  /*

** Attempt to get our data for the application calling us. This is where we

** store whatever application-specific information we need to carry in support

** of calling applications.

   * Attempt to get our data for the application calling us. This is where we

   * store whatever application-specific information we need to carry in

   * support of calling applications.

   */

  app_data = (libdata_t *) get_app_data(id);

  if(!app_data) {

    /*

** This application hasn't called us before; set up application AND per-thread

** data. Of course, just in case a thread from this same application is calling

** us simultaneously, we better lock our application data-creation mutex. We

** also need to recheck for data after we acquire the lock because WE might be

** that other thread that was too late to create the data and the first thread

** in will have created it.

     * This application hasn't called us before; set up application AND

     * per-thread data. Of course, just in case a thread from this same

     * application is calling us simultaneously, we better lock our application

     * data-creation mutex. We also need to recheck for data after we acquire

     * the lock because WE might be that other thread that was too late to

     * create the data and the first thread in will have created it.

     */

    NXLock(gLibLock);

        if(app_data) {

          /*

** Here we burn in the application data that we were trying to get by calling

** get_app_data(). Next time we call the first function, we'll get this data

** we're just now setting. We also go on here to establish the per-thread data

** for the calling thread, something we'll have to do on each application

** thread the first time it calls us.

           * Here we burn in the application data that we were trying to get

           * by calling get_app_data(). Next time we call the first function,

           * we'll get this data we're just now setting. We also go on here to

           * establish the per-thread data for the calling thread, something

           * we'll have to do on each application thread the first time

           * it calls us.

           */

          err = set_app_data(gLibId, app_data);

        && !(err = NXKeyGetValue(key, (void **) &thread_data))

        && !thread_data) {

      /*

** Allocate the per-thread data for the calling thread. Regardless of whether

** there was already application data or not, this may be the first call by a

** a new thread. The fact that we allocation 20 bytes on a pointer is not very

** important, this just helps to demonstrate that we can have arbitrarily

** complex per-thread data.

       * Allocate the per-thread data for the calling thread. Regardless of

       * whether there was already application data or not, this may be the

       * first call by a new thread. The fact that we allocation 20 bytes on

       * a pointer is not very important, this just helps to demonstrate that

       * we can have arbitrarily complex per-thread data.

       */

      thread_data = malloc(sizeof(libthreaddata_t));

  if(!socks5_resolve_local) {

    socksreq[len++] = 3; /* ATYP: domain name = 3 */

    socksreq[len++] = (char) hostname_len; /* address length */

    memcpy(&socksreq[len], hostname, hostname_len); /* address bytes w/o NULL */

    memcpy(&socksreq[len], hostname, hostname_len); /* address str w/o NULL */

    len += hostname_len;

  }

  else {

      int i;

      if(hp->ai_family == AF_INET) {

        socksreq[len++] = 1; /* IPv4 = 1 */

        socksreq[len++] = 1; /* ATYP: IPv4 = 1 */

        saddr_in = (struct sockaddr_in*)hp->ai_addr;

        for(i = 0; i < 4; i++) {

        }

      }

      else if(hp->ai_family == AF_INET6) {

        socksreq[len++] = 4; /* IPv6 = 4 */

        socksreq[len++] = 4; /* ATYP: IPv6 = 4 */

        saddr_in6 = (struct sockaddr_in6*)hp->ai_addr;

        for(i = 0; i < 16; i++) {