daq/slc/nsm2/corelib/nsmlib2.c

Bug Summary

File:	daq/slc/nsm2/corelib/nsmlib2.c
Warning:	line 1445, column 9 Null pointer passed to 2nd parameter expecting 'nonnull'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -O3 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name nsmlib2.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=none -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/data/b2soft/buildbot/development/build -fcoverage-compilation-dir=/data/b2soft/buildbot/development/build -resource-dir /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/python3.12 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/CLHEP -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/Geant4 -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/root -isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/include/belle_legacy -I include/ -D _PACKAGE_="daq" -D G4UI_USE_TCSH -D RaveDllExport= -D HAS_SQLITE -D HAS_CALLGRIND -I daq/slc/nsm2/include -I /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/include/libxml2 -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/lib/clang/21/include -internal-isystem /usr/local/include -internal-isystem /cvmfs/belle.cern.ch/el9/externals/v02-04-00/Linux_x86_64/common/bin/../lib64/gcc/x86_64-redhat-linux/15.2.0/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-missing-braces -Wno-unused-command-line-argument -ferror-limit 19 -fgnuc-version=4.2.1 -fskip-odr-check-in-gmf -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /scan_build/2026-05-31-004316-385593-1 -x c daq/slc/nsm2/corelib/nsmlib2.c
1/**************************************************************************
* basf2 (Belle II Analysis Software Framework)                           *
* Author: The Belle II Collaboration                                     *
*                                                                        *
* See git log for contributors and copyright holders.                    *
* This file is licensed under LGPL-3.0, see LICENSE.md.                  *
**************************************************************************/

9/* ---------------------------------------------------------------------- *\
 nsmlib2.c

 NSM client library
 core part, independent of general usage

 All external library functions have prefix "nsmlib_".

 20131216 1912 sa_flags fix (work works with gcc 4.1.2)
 20131230 1918 strerror fix, initnet fix, stdint fix, bridge fix
 20140104 1919 strerror rearranged
 20140105 1921 fix for incorrect errc in register_request
 20140108 1922 initcli error message fix
 20140124 1925 anonymous node
 20140304 1926 abort when new revision data is started elsewhere
 20140305 1929 maxrecursive and checkpoints, no fprintf
 20140306 1930 logfp again, but write instead of fwrite/fprintf
 20140516 1931 ip address from shm if not specified
 20140614 1932 sprintf ip address if host is missing
 20140614 1933 use nodhash for nsmlib_nodeid
 20140902 1935 memset fix
 20140903 1937 nsmparse fix (see nsmparse.c)
 20140917 1939 skip revision check for -1
 20140921 1940 flushmem
 20180709 1974 free unused parse results, memory leak fix in nsm_init2
 20180802 1977 free pipe in nsmlib_shutdown
 20180913 1990 error message update for unknown reqid
 20181126 1994 nsmlib_nodeproc is added
 20190415 1994 add: nsmc->errno
 20190419 1994 add: NSMENODEST on send error
 20190529 1994 fix: nsmlib_nodeid/proc null sysp handling
 20190725 1997 add: library version at init / in shm
 20190909 1999 fix: unnecessary printf
 20190913 1999 nsmlib_logging returns previous value
 20190918 1999 mod: nsmlib_call log message for unregistered request
 20191002 1999 mod: nsmsys2.h is no more included in nsmlib2.h
 20200123 1999 mod: error code for read/write timeout
 20200423 2003 mod: implement read(init)/write timeout
 20200423 2003 mod: 1 second penalty when sending non-existing req
 20200603 2006 fix: nnod in ntohs
 20210315 2007 fix: nsmlib_parsefree fix for nsmlib_allocmem
 20220425 2008 fix: uint16_t to int conversion fix for nnod
51\* ---------------------------------------------------------------------- */

53const char *nsmlib2_version   = "nsmlib2 2.0.08";

55/* -- includes -- */
56#include <stdio.h>
57#include <stdlib.h>
58#include <stdint.h>
59#include <stdarg.h>
60#include <unistd.h>
61#include <string.h>
62#include <ctype.h>
63#include <signal.h>
64#include <errno(*__errno_location ()).h>
65#include <netdb.h> /* for struct hostent */
66#include <net/if.h> /* for struct ifconf, ifreq */
67#include <sys/socket.h> /* for ntoha etc */
68#include <netinet/in.h> /* for ntoha etc */
69#include <arpa/inet.h>  /* for ntoha etc */
70#include <sys/types.h>
71#include <sys/time.h>
72#include <sys/ioctl.h>
73#include <sys/select.h>
74#include <sys/stat.h>
75#include <sys/shm.h>

77#include "nsm2/nsm2.h"
78#include "nsm2/nsmsys2.h"
79#include "nsm2/nsmlib2.h"
80#include "nsm2/nsmparse.h"

82/* -- default constants -- */
83#define NSM2_PORT8120 8120 /* chosen as it corresponds to 0x2012
	  (2012 is the year started writing NSM2) */
85#define NSMENV_HOST"NSM2_HOST"   "NSM2_HOST"
86#define NSMENV_PORT"NSM2_PORT"   "NSM2_PORT"
87#define NSMENV_SHMKEY"NSM2_SHMKEY" "NSM2_SHMKEY"

89#define NSMLIB_MAXRECURSIVE256 256    /* default value */

91/* -- global variables -- */
92static NSMcontext *nsmlib_context = 0;  /* top of the chain */
93static FILE *nsmlib_logfp = 0;
94static int   nsmlib_loglen = 0;
95static char  nsmlib_logbuf[4096];
96static char *nsmlib_incpath = 0;
97static char  nsmlib_errs[1024];    /* error string in case of NSMEUNEXPECTED */
98static int   nsmlib_errc = 0;      /* context independent error code */
99static int   nsmlib_port = 0;      /* error port without context */

101static int   nsmlib_debugflag = 0; /* context independent error code */
102static sigset_t nsmlib_sigmask;
103static int   nsmlib_sig;

105static int  nsmlib_maxrecursive;
106int  nsmlib_currecursive;
107static int *nsmlib_checkpoints;
108static int  nsmlib_nskipped;
109static NSMtcphead nsmlib_lastskipped;
110/* static int nsmlib_alloccnt = 0; /* (2018.0709.0934 memory leak search) */

112typedef struct NSMrecvqueue_struct {
struct NSMrecvqueue_struct *next;
NSMtcphead h;
115} NSMrecvqueue;

117/* -- macros -- */
118#define ADDR_N(a)((uint32_t)((a).sin_addr.s_addr))    ((uint32_t)((a).sin_addr.s_addr))
119#define LOGEND(nsmlib_logbuf + nsmlib_loglen) (nsmlib_logbuf + nsmlib_loglen)
120#define LOGCLRnsmlib_loglen = 0 nsmlib_loglen = 0
121#define LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) (sizeof(nsmlib_logbuf) - nsmlib_loglen - 1)
122#define LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen)) nsmlib_loglen += strlen(LOGEND(nsmlib_logbuf + nsmlib_loglen))
123#define LOGCAT(s)strcpy((nsmlib_logbuf + nsmlib_loglen), s); nsmlib_loglen += strlen
((nsmlib_logbuf + nsmlib_loglen)) strcpy(LOGEND(nsmlib_logbuf + nsmlib_loglen), s); LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen))

125#define VSNPRINTF(buf,s,f,ap)__builtin_va_start(ap, f);vsnprintf(buf,s,f,ap);__builtin_va_end
(ap) va_start(ap,f)__builtin_va_start(ap, f);vsnprintf(buf,s,f,ap);va_end(ap)__builtin_va_end(ap)
126#define SOCKOPT(s,o,v)setsockopt(s,1,o,(char *)&(v),sizeof(v))        setsockopt(s,SOL_SOCKET1,o,(char *)&(v),sizeof(v))

128#define MEMPOS(base,ptr)((char *)(ptr) - (char *)(base)) ((char *)(ptr) - (char *)(base))
129#define MEMPTR(base,off)((char *)(base) + off) ((char *)(base) + off)

131#define ASSERTnsmlib_assert nsmlib_assert
132#define ERRORnsmlib_error  nsmlib_error
133#define DBGnsmlib_debug    nsmlib_debug
134#define LOGnsmlib_lognl    nsmlib_lognl

136/* checkpoint of signal handler to be studied with gdb
 0: never called, -1: done, 1..1000 user checkpoint, 1001.. corelib/b2lib
*/
139#define DBS(nsmc,val)nsmlib_checkpoints[nsmlib_currecursive] = (val) nsmlib_checkpoints[nsmlib_currecursive] = (val)

141/* -- extern functions -- */
142/* implemented in nsmhash.c */
143int nsmlib_hash(NSMsys *, int32_t *hashtable, int hashmax,
const char *key, int create);


147/* -- free ------------------------------------------------------------ */
148static void
149nsmlib_free(void *ptr)
150{
if (! ptr) {
  printf("nsmlib_free: freeing null pointer\n");
  exit(1);
}
int32_t siz = *(int32_t *)((char *)ptr - 4);
if (siz == 0) {
  printf("nsmlib_free: possible double free attempt\n");
  exit(1);
}

/* -- 2018.0709.0435 memory leak search
nsmlib_alloccnt--;
{
  static int callcnt = 0;
  callcnt++;
  if (callcnt < 20) {
    printf("nsmlib_free siz=%d\n", siz);
  }
}
*/

*(int32_t *)((char *)ptr - 4) = 0;
free((char *)ptr-4);
174}
175/* -- malloc ---------------------------------------------------------- */
176static void *
177nsmlib_malloc(size_t siz, const char *where, const char *text)
178{
char *p = (char *)malloc(siz+4);
if (! p) {
  printf("nsmlib_malloc: can't malloc %d bytes%s%s%s%s\n",
  (int)siz,
  where ? " in " : "", where ? where : "",
  text  ? ": "   : "", text  ? text  : "");
  exit(1);
}
memset(p, 0, siz+4);

/* -- 2018.0709.0936 memory leak search
{
  static int callcnt = 0;
  nsmlib_alloccnt++;
  callcnt++;
  if (callcnt < 20) {
    printf("nsmlib_malloc where=%s text=%s\n",
           where ? where : "(nowhere?)",
           text ? text : "(notext)");
  }
  if ((callcnt % 100) == 0) {
    printf("nsmlib_malloc +%d / %d\n", nsmlib_alloccnt, callcnt);
  }
}
*/

*(int32_t *)p = (int32_t)siz;
return p+4;
207}
208/* -- time1ms -------------------------------------------------------- */
209static uint64
210time1ms()
211{
struct timeval tv;
gettimeofday(&tv, 0);
return (uint64)tv.tv_sec * 1000 + tv.tv_usec / 1000; /* in 1msec unit */
215}
216/* -- htonll --------------------------------------------------------- */
217static uint64
218htonll(uint64 h)
219{
static int n42 = 0;
if (n42 == 0) n42 = htons(42)__bswap_16 (42); /* 42 is the answer */
if (n42 == 42) {
  return h;
} else {
  uint64 n;
  int32_t *hp = (int32_t *)&h;
  int32_t *np = (int32_t *)&n;
  np[0] = htonl(hp[1])__bswap_32 (hp[1]);
  np[1] = htonl(hp[0])__bswap_32 (hp[0]);
  return n;
}
232}
233/* -- nsmlib_logflush ------------------------------------------------ */
234void
235nsmlib_logflush()
236{
/*
  (fwrite version does not properly work at 1.9.30)
  fwrite(nsmlib_logbuf, nsmlib_loglen, 1, nsmlib_logfp);
  fflush(nsmlib_logfp);
*/
if (nsmlib_loglen) {
  write(fileno(nsmlib_logfp), nsmlib_logbuf, nsmlib_loglen);
  LOGCLRnsmlib_loglen = 0;
}
246}
247/* -- nsmlib_assert -------------------------------------------------- */
248static void
249nsmlib_assert(const char *fmt, ...)
250{
va_list ap;
if (! nsmlib_logfp) return;

if (LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) < 256) {
  LOGCLRnsmlib_loglen = 0;
  LOGCAT("(output buffer shrinked)\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "(output buffer shrinked)\n"
); nsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
}

LOGCAT("ASSERT: ")strcpy((nsmlib_logbuf + nsmlib_loglen), "ASSERT: "); nsmlib_loglen
 += strlen((nsmlib_logbuf + nsmlib_loglen));
VSNPRINTF(LOGEND, LOGSIZ, fmt, ap)__builtin_va_start(ap, fmt);vsnprintf((nsmlib_logbuf + nsmlib_loglen
),(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1),fmt,ap);__builtin_va_end
(ap);
LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
LOGCAT("\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "\n"); nsmlib_loglen +=
 strlen((nsmlib_logbuf + nsmlib_loglen));
nsmlib_logflush();
exit(1);
265}
266/* -- nsmlib_error --------------------------------------------------- */
267static void
268nsmlib_error(const char *fmt, ...)
269{
va_list ap;

if (! nsmlib_logfp) return;

if (LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) < 256) {
  LOGCLRnsmlib_loglen = 0;
  LOGCAT("(output buffer shrinked)\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "(output buffer shrinked)\n"
); nsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
}

LOGCAT("ERROR: ")strcpy((nsmlib_logbuf + nsmlib_loglen), "ERROR: "); nsmlib_loglen
 += strlen((nsmlib_logbuf + nsmlib_loglen));
VSNPRINTF(LOGEND, LOGSIZ, fmt, ap)__builtin_va_start(ap, fmt);vsnprintf((nsmlib_logbuf + nsmlib_loglen
),(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1),fmt,ap);__builtin_va_end
(ap);
LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
LOGCAT("\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "\n"); nsmlib_loglen +=
 strlen((nsmlib_logbuf + nsmlib_loglen));
nsmlib_logflush();
284}
285/* -- nsmlib_debuglevel ---------------------------------------------- */
286int
287nsmlib_debuglevel(int val)
288{
int prev = nsmlib_debugflag;
nsmlib_debugflag = val;
return prev;
292}
293/* -- nsmlib_debug --------------------------------------------------- */
294static void
295nsmlib_debug(const char *fmt, ...)
296{
va_list ap;
if (! nsmlib_logfp) return;
if (! nsmlib_debugflag) return;

if (LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) > 256) {
  LOGCAT("[DBG] ")strcpy((nsmlib_logbuf + nsmlib_loglen), "[DBG] "); nsmlib_loglen
 += strlen((nsmlib_logbuf + nsmlib_loglen));
  VSNPRINTF(LOGEND, LOGSIZ, fmt, ap)__builtin_va_start(ap, fmt);vsnprintf((nsmlib_logbuf + nsmlib_loglen
),(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1),fmt,ap);__builtin_va_end
(ap);
  LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
  LOGCAT("\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "\n"); nsmlib_loglen +=
 strlen((nsmlib_logbuf + nsmlib_loglen));
}
307}
308/* -- nsmlib_lognl --------------------------------------------------- */
309void
310nsmlib_lognl(const char *fmt, ...)
311{
va_list ap;
if (! nsmlib_logfp) return;
if (LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) > 256) {
  VSNPRINTF(LOGEND, LOGSIZ, fmt, ap)__builtin_va_start(ap, fmt);vsnprintf((nsmlib_logbuf + nsmlib_loglen
),(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1),fmt,ap);__builtin_va_end
(ap);
  LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
  LOGCAT("\n")strcpy((nsmlib_logbuf + nsmlib_loglen), "\n"); nsmlib_loglen +=
 strlen((nsmlib_logbuf + nsmlib_loglen));
}
319}
320/* -- nsmlib_log ----------------------------------------------------- */
321void
322nsmlib_log(const char *fmt, ...)
323{
va_list ap;
if (! nsmlib_logfp) return;
if (LOGSIZ(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1) > 256) {
  VSNPRINTF(LOGEND, LOGSIZ, fmt, ap)__builtin_va_start(ap, fmt);vsnprintf((nsmlib_logbuf + nsmlib_loglen
),(sizeof(nsmlib_logbuf) - nsmlib_loglen - 1),fmt,ap);__builtin_va_end
(ap);
  LOGFWDnsmlib_loglen += strlen((nsmlib_logbuf + nsmlib_loglen));
}
330}
331/* -- nsmlib_logging ------------------------------------------------- */
332FILE *
333nsmlib_logging(FILE *logfp)
334{
FILE *prevfp = nsmlib_logfp;
nsmlib_logfp = logfp;
return prevfp;
338}

340/* -- nsmlib_checkpoint ---------------------------------------------- *\
 for user function, between 1 and 999 (outside range becomes 1000)
342\* ------------------------------------------------------------------- */
343void
344nsmlib_checkpoint(NSMcontext *nsm, int val)
345{
DBS(nsm, val)nsmlib_checkpoints[nsmlib_currecursive] = (val);
347}
348/* -- nsmlib_strerror ------------------------------------------------ */
349const char *
350nsmlib_strerror(NSMcontext *nsmc)
351{
static char buf[256];
char *syserr = 0;
int         errc = nsmc ? nsmc->errc : nsmlib_errc;
const char *errs = nsmc ? nsmc->errs : nsmlib_errs;
int         errn = nsmc ? nsmc->errn : errno(*__errno_location ());
int         shmkey = nsmc ? nsmc->shmkey : nsmlib_port;

switch (errc) {
case NSMENOERR(0): return nsmc ? "no error" : "NSM is not initialized";
case NSMEALLOC(-101): syserr = "malloc"; break;
case NSMESOCKET(-102): syserr = "socket"; break;
case NSMESOCKDGRAM(-103): syserr = "socket(sock_dgram)"; break;
case NSMEGIFCONF(-104): syserr = "ioctl(SIOCGIFCONF)"; break;
case NSMEGIFFLAGS(-105): syserr = "ioctl(SIOCGIFFLAGS)"; break;
case NSMESOCKREUSE(-106): syserr = "so_sockreuse"; break;
case NSMESOCKSNDBUF(-107): syserr = "so_sndbuf";    break;
case NSMESOCKRCVBUF(-108): syserr = "so_rcvbuf";    break;
case NSMERDSELECT(-109): syserr = "select(read)"; break;
case NSMERDUID(-110):    syserr = "uid read error"; break;
case NSMENOPIPE(-111):   syserr = "pipe"; break;
case NSMESELECT(-112):   syserr = "select"; break;
case NSMETIMEOUT(-113):  return "select timeout"; /* until 1998 */
case NSMETIMEOUTW(-41): return "timeout in sending to nsmd2";
case NSMETIMEOUTR(-42): return "timeout in receiving from nsmd2";
case NSMEWRITE(-114):    syserr = "write(socket)"; break;
case NSMEUNEXPECTED(-119): return errs;
case NSMECLOSED(-115):    return "NSMD connection closed";
case NSMEPIPEREAD(-116):  syserr = "read(pipe)"; break;
case NSMEPIPEWRITE(-117): syserr = "write(pipe)"; break;
case NSMEDATID(-118): return errs;
  /* possible errors by user parameters */
case NSMENOMASTER(-1):  return "no master nsmd2";
case NSMENGMASTER(-40):  return "master nsmd2 temporarily unreachable";
case NSMEINVNAME(-2):   return "invalid name"; /* from nsmd2, shouldn't happen */
case NSMEINVPAR(-3):    return "invalid parameter";
case NSMENODEEXIST(-4): return errs; /* "node already exist" from nsmd2 */
case NSMENODEHERE(-45):  return errs; /* "node already exist here" from nsmd2 */
case NSMEFULNODE(-5):   return errs; /* "no more NSM node"   from nsmd2 */
case NSMENODEST(-6):    return "destination node does not exist";
case NSMEINVFMT(-7):    return "invalid data format"; /* from nsmd2 */
case NSMEMEMEXIST(-8):  return "data alraedy exists"; /* why unused? */
case NSMENOMOREMEM(-9): return "no more data area"; /* why unused? */
case NSMEOPENED(-10):    return "already opened"; /* from nsmd2 */
case NSMENODENAME(-11):  return "invalid node name";
case NSMENODELONG(-12):  return "node name too long"; /* why unused? */
case NSMEHOSTNAME(-13):  return "invalid hostname";
case NSMEALREADYP(-14):  return "host:port already in use";
case NSMEALREADYS(-15):  return "shm key already in use";
case NSMEALREADYH(-16):  return "host:port already in use"; /* deprecated */
case NSMENOIF(-17):      return "network interface not found";
case NSMENONSMD(-18):    return "orphan shared memory with no nsmd2 running";
case NSMECONNECT(-35):   syserr = "cannot connect to nsmd2"; break;
case NSMENOUID(-19):     return "uid not received";
  /* case NSMERDCLOSE:   return "uid not fully received"; */
case NSMERDCLOSE(-20):   return "cannot communicate with nsmd2";
case NSMEACCESS(-21):    return "nsmd2 is running under different uid";
case NSMESHMNOSYS(-37):
  sprintf(buf, "no shared memory with port/shmkey=%d", shmkey);
  return buf;
case NSMESHMGETSYS(-22): syserr = "cannot open NSMsys shared memory"; break;
case NSMESHMACCES(-38):
  return "nsmd2 shared memory must have either the same uid or gid";
case NSMESHMGETMEM(-24):
  syserr = "cannot open NSMmem shared memory"; break;
case NSMESHMATSYS(-23): syserr = "shmat(NSMsys)"; break;
case NSMESHMATMEM(-25): syserr = "shmat(NSMmem)"; break;
case NSMENOINIT(-26):  return "NSM2 is not initialized yet";
case NSMEPERM(-27):    return "operation not allowed for anonymous node";
case NSMEINVDATA(-28): return "invalid send data parameter";
case NSMEINVFUNC(-29): return "invalid callback function type";
case NSMEMAXFUNC(-30): return "no more callback functions";
case NSMENOMEM(-31):   return errs; /* openmem */
case NSMEBADFMT(-32):  return errs; /* openmem */
case NSMEBADREV(-33):  return errs; /* openmem/allocmem */
case NSMEPARSE(-34):   return errs; /* openmem/allocmem */
case NSMEINVPTR(-36):  return "invalid pointer";
case NSMEEMPTYDEST(-39): return "empty destination";
case NSMENOSUCHREQ(-43): return "no such registered request";
case NSMEBADHASH(-44):   return "broken internal hash";

default:
  if (*errs) return errs;
  if (! nsmc) {
    sprintf(buf, "NSM is not initialized (errcode=%d)", errc);
  } else {
    sprintf(buf, "undefined error code (errcode=%d)", errc);
  }
  return buf;
}

if (syserr) {
  sprintf(buf, "%s: %s", syserr, strerror(errn));
}
return buf;
446}
447/* -- nsmlib_atoi ---------------------------------------------------- */
448static int
449nsmlib_atoi(const char *a, int def)
450{
if (! a || ! *a) return def;
if (! (isdigit(*a)((*__ctype_b_loc ())[(int) ((*a))] & (unsigned short int)
 _ISdigit) || (*a == '-' && isdigit(*(a+1))((*__ctype_b_loc ())[(int) ((*(a+1)))] & (unsigned short int
) _ISdigit)))) {
  return def;
} else {
  return (int)strtol(a,0,0);
}
457}

459/* -- nsmlib_addincpath ---------------------------------------------- */
460int
461nsmlib_addincpath(const char *path)
462{
if (! path) {
  if (nsmlib_incpath) nsmlib_free(nsmlib_incpath);
  nsmlib_incpath = 0;
  return 0;
} else {
  /*
     If "path" is not a directory, take the string up to the last '/'.
     This is the way to easily add the path of the program, by
     nsmlib_addincpath(argv[0])
  */
  const char *p;
  int len = nsmlib_incpath ? strlen(nsmlib_incpath) + 1 : 0;
  struct stat statbuf;
  while (stat(path, &statbuf) < 0) {
    if (errno(*__errno_location ()) != EINTR4) return -1;
  }
  
  if (S_ISDIR(statbuf.st_mode)((((statbuf.st_mode)) & 0170000) == (0040000))) {
    len += strlen(path) + 1;
    p = path + len;
  } else {
    if (! (p = strrchr(path, '/'))) return -1;
    len += (p - path) + 1;
  }
  char *q = (char *)nsmlib_malloc(len, "incpath", path);
  if (! q) ASSERTnsmlib_assert("nsmlib_addincpath can't malloc %d byte", len);
  if (nsmlib_incpath) {
    sprintf(q, "%s:", nsmlib_incpath);
  } else {
    *q = 0;
  }
  strncat(q, path, p - path);
  q[len-1] = 0;
  if (nsmlib_incpath) nsmlib_free(nsmlib_incpath);
  nsmlib_incpath = q;
}
499}

501/* -- nsmlib_nodename ------------------------------------------------ */
502const char *
503nsmlib_nodename(NSMcontext *nsmc, int nodeid)
504{
int i;
NSMsys *sysp;
const char *namep;
if (! nsmc || ! (sysp = nsmc->sysp)) return 0;

if (nodeid == NSMSYS_MAX_NOD1024) return "(no-name)";
if (nodeid < 0 || nodeid > NSMSYS_MAX_NOD1024) return "(invalid)";
namep = sysp->nod[nodeid].name;
if (! namep[0]) return 0;
for (i=0; i <= NSMSYS_NAME_SIZ31; i++) {
  if (namep[i] == 0) break;
  if (! isalnum(namep[i])((*__ctype_b_loc ())[(int) ((namep[i]))] & (unsigned short
 int) _ISalnum) && namep[i] != '_') return "(broken)";
}
if (i > NSMSYS_NAME_SIZ31) return "(broken)";
return namep;
520}

522/* -- nsmlib_nodeid -------------------------------------------------- */
523int
524nsmlib_nodeid(NSMcontext *nsmc, const char *nodename)
525{
int i;
NSMsys *sysp;
const char *namep;
int hash;
NSMnod *nodp;

if (! nsmc || ! (sysp = nsmc->sysp)) return -1;
if (! nodename || ! *nodename || *nodename == '(') return -1;

hash = nsmlib_hash(sysp, sysp->nodhash, NSMSYS_MAX_HASH2039, nodename, 0);
if (hash < 0) return -1;

nodp = (NSMnod *)MEMPTR(sysp, ntohl(sysp->nodhash[hash]))((char *)(sysp) + __bswap_32 (sysp->nodhash[hash]));
return (int)(nodp - sysp->nod);
540}

542/* -- nsmlib_nodepid ------------------------------------------------- */
543int
544nsmlib_nodepid(NSMcontext *nsmc, const char *nodename)
545{
int inod = nsmlib_nodeid(nsmc, nodename);
if (inod < 0) return -1;
return ntohl(nsmc->sysp->nod[inod].nodpid)__bswap_32 (nsmc->sysp->nod[inod].nodpid);
549}

551/* -- nsmlib_nodeproc ------------------------------------------------ */
552/*
ipaddress for a remote node, or nodepid for a local node.
(local if the return value < NSMSYS_MAX_NOD, assuming no ip address
 0.0.0.0/22 is used)
556*/
557int
558nsmlib_nodeproc(NSMcontext *nsmc, const char *nodename)
559{
int i;
NSMsys *sysp;
if (! nsmc || ! (sysp = nsmc->sysp)) return -1;

int nodeid = nsmlib_nodeid(nsmc, nodename);
if (nodeid < 0) return nodeid;

if (sysp->nod[nodeid].ipaddr == -1) return 0;
if (sysp->nod[nodeid].ipaddr != sysp->ipaddr)
  return sysp->nod[nodeid].ipaddr;

if (sysp->nod[nodeid].nodpid == -1) return 0;
return ntohl(sysp->nod[nodeid].nodpid)__bswap_32 (sysp->nod[nodeid].nodpid);
573}

575/* -- nsmlib_checkif ------------------------------------------------- */
576/*
 Check the ethernet interface and determine the IP address to use.
578*/
579static int
580nsmlib_checkif(NSMcontext *nsmc, SOCKAD_IN *sap)
581{
int sock; // use only inside this function, close before return
struct ifconf ifc;
struct ifreq *ifr;
char buf[4096];
int ifrgap;

/* -- open socket -- */
if ((sock = socket(AF_INET2, SOCK_DGRAMSOCK_DGRAM, 0)) < 0) {
  ERRORnsmlib_error("nsmlib_checkif: socket");
  nsmc->errn = errno(*__errno_location ());
  return NSMESOCKDGRAM(-103);
}

/* -- broadcast address (only for the first, except localhost) -- */
memset(buf, 0, sizeof(buf));
ifc.ifc_len = sizeof(buf);
ifc.ifc_bufifc_ifcu.ifcu_buf = buf;
if (ioctl(sock, SIOCGIFCONF0x8912, (char *)&ifc) < 0) {
  ERRORnsmlib_error("nsmlib_checkif: ioctl getconf");
  nsmc->errn = errno(*__errno_location ());
  close(sock);
  return NSMEGIFCONF(-104);
}

for (ifr = ifc.ifc_reqifc_ifcu.ifcu_req;
     (char *)ifr < (char *)ifc.ifc_reqifc_ifcu.ifcu_req + ifc.ifc_len;
     ifr = (struct ifreq *)((char *)ifr + ifrgap)) {
  
610#if defined(__FreeBSD__) || defined(MVME5100)
  /* This ugly code is taken from bind 4.8.x for FreeBSD */
  /* VxWorks on MVME5100 requires this, too */
613#define xxx_max(a,b) ((a)>(b)?(a):(b))
614#define xxx_size(p)  xxx_max((p).sa_len,sizeof(p))
  ifrgap = sizeof(ifr->ifr_nameifr_ifrn.ifrn_name) + xxx_size(ifr->ifr_addrifr_ifru.ifru_addr);
616#else
  ifrgap = sizeof(*ifr);
618#endif
  
  if (! ifr->ifr_nameifr_ifrn.ifrn_name[0]) break;
  DBGnsmlib_debug("nsmlib_checkif: checking interface <%s>", ifr->ifr_nameifr_ifrn.ifrn_name);
  
  if (ioctl(sock, SIOCGIFFLAGS0x8913, (char *)ifr) < 0) {
    ERRORnsmlib_error("nsmlib_checkif: ioctl getflags");
    nsmc->errn = errno(*__errno_location ());
    close(sock);
    return NSMEGIFFLAGS(-105);
    
  } else if ((ifr->ifr_flagsifr_ifru.ifru_flags & IFF_UPIFF_UP) == 0) {
    DBGnsmlib_debug("nsmlib_checkif: interface <%s> is down", ifr->ifr_nameifr_ifrn.ifrn_name);
    
  } else if ((ifr->ifr_flagsifr_ifru.ifru_flags & IFF_BROADCASTIFF_BROADCAST) == 0 &&
             (ifr->ifr_flagsifr_ifru.ifru_flags & IFF_LOOPBACKIFF_LOOPBACK) == 0) {
    DBGnsmlib_debug("nsmlib_checkif: interface <%s> does not support broadcast",
 ifr->ifr_nameifr_ifrn.ifrn_name);

  } else if (ioctl(sock, SIOCGIFADDR0x8915, (char *)ifr) < 0) {
    DBGnsmlib_debug("nsmlib_checkif: interface <%s> has no address", ifr->ifr_nameifr_ifrn.ifrn_name);
    
  } else {
    SOCKAD_IN sa;
    memcpy(&sa, (SOCKAD_IN *)&ifr->ifr_addrifr_ifru.ifru_addr, sizeof(sa));
  
    if (sa.sin_addr.s_addr != sap->sin_addr.s_addr) {
DBGnsmlib_debug("nsmlib_checkif: address does not match for interface <%s>",
   ifr->ifr_nameifr_ifrn.ifrn_name);
    } else {
close(sock);
return 0;
    }
  }
}

DBGnsmlib_debug("nsmlib_checkif: cannot find network interface for %s",
    inet_ntoa(sap->sin_addr));

close(sock);
return NSMENOIF(-17);
659}
660/* -- nsmlib_initnet ------------------------------------------------- */
661/*
since nsm-1931 second argument is unused.
*/
664int
665nsmlib_initnet(NSMcontext *nsmc, const char *unused, int port)
666{
struct hostent *hp;
NSMcontext *nsmcp;
int ret;
int TRUE = 1;
int size = NSM_TCPBUFSIZ(256*4 + 65536);
uid_t nsmd_euid;
fd_set fdset;
struct timeval tv;

/* -- check process -- */
if (kill(nsmc->sysp->pid, 0) < 0 && errno(*__errno_location ()) == ESRCH3) {
  return NSMENONSMD(-18);
}

/* -- port and host -- */
memset(nsmc->hostname, 0, sizeof(nsmc->hostname));
memset(&nsmc->sa, 0, sizeof(nsmc->sa));

memcpy(&nsmc->sa.sin_addr, &nsmc->sysp->ipaddr, 4);
hp = gethostbyaddr(&nsmc->sa.sin_addr, 4, AF_INET2);
if (hp) {
  strcpy(nsmc->hostname, hp->h_name);
} else {
  sprintf(nsmc->hostname, "%d.%d.%d.%d",
   ((const char *)&nsmc->sysp->ipaddr)[0],
   ((const char *)&nsmc->sysp->ipaddr)[1],
   ((const char *)&nsmc->sysp->ipaddr)[2],
   ((const char *)&nsmc->sysp->ipaddr)[3]);
}

nsmc->sa.sin_family = AF_INET2;
nsmc->sa.sin_port   = htons((short)nsmc->port)__bswap_16 ((short)nsmc->port);

/* -- check if this port is already used -- */
for (nsmcp = nsmlib_context; nsmcp; nsmcp = nsmcp->next) {
  if (nsmc == nsmcp) continue;
  if (nsmc->shmkey     == nsmcp->shmkey)     return NSMEALREADYS(-15);
  if (nsmc->port == nsmcp->port &&
ADDR_N(nsmc->sa)((uint32_t)((nsmc->sa).sin_addr.s_addr)) == ADDR_N(nsmcp->sa)((uint32_t)((nsmcp->sa).sin_addr.s_addr))) return NSMEALREADYP(-14);
}

/* -- open a socket -- */
if ((nsmc->sock = socket(AF_INET2, SOCK_STREAMSOCK_STREAM, 0)) < 0) return NSMESOCKET(-102);

/* -- check interface -- */
if ((ret = nsmlib_checkif(nsmc, &nsmc->sa)) < 0) return ret;

/* -- socket options -- */
if (SOCKOPT(nsmc->sock, SO_REUSEADDR, TRUE)setsockopt(nsmc->sock,1,2,(char *)&(TRUE),sizeof(TRUE)
) < 0) {
  nsmc->errn = errno(*__errno_location ());
  return NSMESOCKREUSE(-106);
}
if (SOCKOPT(nsmc->sock, SO_SNDBUF,    size)setsockopt(nsmc->sock,1,7,(char *)&(size),sizeof(size)
) < 0) {
  nsmc->errn = errno(*__errno_location ());
  return NSMESOCKSNDBUF(-107);
}
if (SOCKOPT(nsmc->sock, SO_RCVBUF,    size)setsockopt(nsmc->sock,1,8,(char *)&(size),sizeof(size)
) < 0) {
  nsmc->errn = errno(*__errno_location ());
  return NSMESOCKRCVBUF(-108);
}

/* -- connect -- */
if (connect(nsmc->sock, (SOCKAD *)&nsmc->sa, sizeof(nsmc->sa)) < 0) {
  nsmc->errn = errno(*__errno_location ());
  return NSMECONNECT(-35);
}

/* -- should receive 4 bytes -- */
FD_ZERO(&fdset)do { unsigned int __i; fd_set *__arr = (&fdset); for (__i
 = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) (
(__arr)->__fds_bits)[__i] = 0; } while (0);
FD_SET(nsmc->sock, &fdset)((void) (((&fdset)->__fds_bits)[((nsmc->sock) / (8 *
 (int) sizeof (__fd_mask)))] |= ((__fd_mask) (1UL << ((
nsmc->sock) % (8 * (int) sizeof (__fd_mask)))))));
tv.tv_sec = 5;
tv.tv_usec = 0;
while (1) {
  ret = select(nsmc->sock+1, &fdset, 0, 0, &tv);
  if (ret <  0 && errno(*__errno_location ()) == EINTR4) continue;
  if (ret <  0) {
    nsmc->errn = errno(*__errno_location ());
    return NSMERDSELECT(-109);
  }
  if (ret == 0) return NSMENOUID(-19);
  break;
}

/* -- check whether the nsmd belongs to the same uid -- */
while (1) {
  ret = read(nsmc->sock, &nsmd_euid, sizeof(nsmd_euid));
  if (ret < 0 && errno(*__errno_location ()) == EINTR4) continue;
  if (ret < 0) {
    nsmc->errn = errno(*__errno_location ());
    return NSMERDUID(-110);
  }
  if (ret < sizeof(nsmd_euid)) return NSMERDCLOSE(-20);
  break;
}

if (nsmd_euid != 0 && nsmd_euid != getuid())
  return NSMEACCESS(-21);

nsmc->initnet_done = 1;

return 0;
768}
769/* -- nsmlib_initshm ------------------------------------------------- */
770/*
initshm has to be called before initnet
*/
773int
774nsmlib_initshm(NSMcontext *nsmc, int shmkey, int port)
775{
/* -- initshm is called before inetnet --*/
nsmc->port   = port;

/* -- environment variables for shmkey -- */
if (! shmkey) shmkey = nsmlib_atoi(getenv(NSMENV_SHMKEY"NSM2_SHMKEY"), port);
nsmc->shmkey = shmkey;

/* -- system shared memory (read-only) -- */
DBGnsmlib_debug("nsmlib_initshm: key=%d size=%d", shmkey, sizeof(NSMsys));
nsmc->sysid = shmget(shmkey, sizeof(NSMsys), 0444);
if (nsmc->sysid < 0) {
  /* -- most likely nsmd is not running,
     -- further check is made in initnet -- */
  nsmc->errn = errno(*__errno_location ());
  return errno(*__errno_location ()) == ENOENT2 ? NSMESHMNOSYS(-37) : NSMESHMGETSYS(-22);
}

nsmc->sysp = (NSMsys *)shmat(nsmc->sysid, 0, SHM_RDONLY010000);
if (nsmc->sysp == (NSMsys *)-1) {
  nsmc->errn = errno(*__errno_location ());
  return NSMESHMATSYS(-23);
}

/* -- data shared memory (read/write) -- */
nsmc->memid = shmget(shmkey+1, sizeof(NSMmem), 0664);
if (nsmc->memid < 0) {
  nsmc->errn = errno(*__errno_location ());
  return errno(*__errno_location ()) == EACCES13 ? NSMESHMACCES(-38) : NSMESHMGETMEM(-24);
}

nsmc->memp = (NSMmem *)shmat(nsmc->memid, 0, 0);
if (nsmc->memp == (NSMmem *)-1) {
  nsmc->errn = errno(*__errno_location ());
  return NSMESHMATMEM(-25);
}

/* -- done -- */
nsmc->initshm_done = 1;
return 0;
815}
816/* -- nsmlib_select -------------------------------------------------- */
817int
818nsmlib_select(int fdr, int fdw, unsigned int msec)
819{
struct timeval tv;
fd_set fdset;
int ret;
if (fdr) fdw = 0;
FD_ZERO(&fdset)do { unsigned int __i; fd_set *__arr = (&fdset); for (__i
 = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) (
(__arr)->__fds_bits)[__i] = 0; } while (0);
FD_SET(fdr + fdw, &fdset)((void) (((&fdset)->__fds_bits)[((fdr + fdw) / (8 * (int
) sizeof (__fd_mask)))] |= ((__fd_mask) (1UL << ((fdr +
 fdw) % (8 * (int) sizeof (__fd_mask)))))));
tv.tv_sec  = msec / 1000;
tv.tv_usec = (msec % 1000) * 1000;
while (1) {
  ret = select(fdr+fdw+1, fdr ? &fdset : 0, fdr ? 0 : &fdset, 0, &tv);
  if (ret != -1 || (errno(*__errno_location ()) != EINTR4 && errno(*__errno_location ()) != EAGAIN11)) break;
}
if (ret < 0) {
  ASSERTnsmlib_assert("nsmlib_select should not reach here - ret=%d", ret);
}
return ret;
836}
837/* -- nsmlib_selectc ------------------------------------------------- */
838/*
usesig = 1 when called from signal handler
           then nsmc->usesig=1 is taken
usesig = 0 when called from the user program
           then nsmc->usesig<1 is taken
*/
844NSMcontext *
845nsmlib_selectc(int usesig, unsigned int msec)
846{
fd_set fdset;
struct timeval tv;
int ret;
int highest = -1;
NSMcontext *nsmc;

FD_ZERO(&fdset)do { unsigned int __i; fd_set *__arr = (&fdset); for (__i
 = 0; __i < sizeof (fd_set) / sizeof (__fd_mask); ++__i) (
(__arr)->__fds_bits)[__i] = 0; } while (0);
for (nsmc = nsmlib_context; nsmc; nsmc = nsmc->next) {
  if (usesig != 0 && nsmc->usesig < 1) continue;
  if (usesig == 0 && nsmc->usesig > 0) continue;
  FD_SET(nsmc->sock, &fdset)((void) (((&fdset)->__fds_bits)[((nsmc->sock) / (8 *
 (int) sizeof (__fd_mask)))] |= ((__fd_mask) (1UL << ((
nsmc->sock) % (8 * (int) sizeof (__fd_mask)))))));
  if (highest < nsmc->sock + 1) highest = nsmc->sock + 1;
}
if (highest == -1) return 0;

tv.tv_sec  = msec / 1000;
tv.tv_usec = (msec % 1000) * 1000;
while (1) {
  ret = select(highest, &fdset, 0, 0, &tv);
  if (ret != -1 || (errno(*__errno_location ()) != EINTR4 && errno(*__errno_location ()) != EAGAIN11)) break;
}
if (ret > 0) {
  for (nsmc = nsmlib_context; nsmc; nsmc = nsmc->next) {
    if (FD_ISSET(nsmc->sock, &fdset)((((&fdset)->__fds_bits)[((nsmc->sock) / (8 * (int)
 sizeof (__fd_mask)))] & ((__fd_mask) (1UL << ((nsmc
->sock) % (8 * (int) sizeof (__fd_mask)))))) != 0)) return nsmc;
  }
  ASSERTnsmlib_assert("nsmlib_selectc should not reach here - no fd");
  return 0;
}
if (usesig > 0 && msec > 0 && ret <= 0) {
  LOGnsmlib_lognl("nsmlib_selectc should not reach here - ret=%d msec=%d usesig=%d",
      ret, msec, nsmc->usesig);
}
return 0;
880}
881/* -- nsmlib_pipewrite ----------------------------------------------- */
882/*
write one int32_t from pipe, to synchronize and get the result
*/
885static int
886nsmlib_pipewrite(NSMcontext *nsmc, int32_t val)
887{
while (1) {
  int ret = write(nsmc->pipe_wr, &val, sizeof(int32_t));
  if (ret < 0 && errno(*__errno_location ()) == EINTR4) continue;
  if (ret < 0) ASSERTnsmlib_assert("nsmlib_pipewrite %s", strerror(errno(*__errno_location ())));
  break;
}
return 0;
895}
896/* -- nsmlib_piperead ------------------------------------------------ */
897/*
read one int32_t from pipe, to synchronize and get the result
*/
900static int
901nsmlib_piperead(NSMcontext *nsmc, int32_t *valp)
902{
DBGnsmlib_debug("piperead 1");
while (1) {
  int ret = read(nsmc->pipe_rd, valp, sizeof(int32_t));
  if (ret < 0 && errno(*__errno_location ()) == EINTR4) continue;
  if (ret < 0) {
    nsmc->errn = errno(*__errno_location ());
    return NSMEPIPEREAD(-116);
  }
  break;
}
DBGnsmlib_debug("piperead done");
return 0;
915}
916/* -- nsmlib_queue --------------------------------------------------- */
917int
918nsmlib_queue(NSMcontext *nsmc, NSMtcphead *hp)
919{
int len = sizeof(NSMtcphead) + sizeof(int32_t)*hp->npar + htons(hp->len)__bswap_16 (hp->len);
NSMrecvqueue *p = nsmlib_malloc(sizeof(struct NSMtcpqueue *) + len,
                                "queue", 0);
if (! p) return 0;

NSMrecvqueue *q = nsmc->recvqueue;
if (! q) {
  nsmc->recvqueue = p;
} else {
  while (q->next) q = q->next;
  q->next = p;
}
p->next = 0;
memcpy((char *)&p->h, (char *)hp, len);
return 0;
935}
936/* -- nsmlib_recv ---------------------------------------------------- */
937int
938nsmlib_recv(NSMcontext *nsmc, NSMtcphead *hp, int wait_msec)
939{
int sock = nsmc->sock;
int ret;
int i;
int recvlen = 0;
int datalen = sizeof(NSMtcphead);
char *bufp  = (char *)hp;

DBGnsmlib_debug("recv 1");
ret = nsmlib_select(sock, 0, wait_msec);
DBGnsmlib_debug("recv 2");
if (ret < 0) ASSERTnsmlib_assert("nsmlib_recv: should not reach here (1)");
if (ret == 0) return 0; /* time out */

for (i=0; i<2; i++) { /* i=0 for header / i=1 for data */
  DBGnsmlib_debug("recv 3 bufp=%x", bufp);
  while (recvlen < datalen) {
    DBGnsmlib_debug("recv 4");
    if (recvlen > 0) ret = nsmlib_select(sock, 0, 100); /* 1 msec */
    if (ret < 0)  ASSERTnsmlib_assert("nsmlib_recv: should not reach here (2)");
    if (ret == 0) ASSERTnsmlib_assert("nsmlib_recv: should not reach here (3)");
    if ((ret = read(sock, bufp+recvlen, datalen)) <= 0) {
if (ret == -1 && errno(*__errno_location ()) == EINTR4) continue;
if (ret < 0) ASSERTnsmlib_assert("nsmlib_recv read error (1) %s", strerror(errno(*__errno_location ())));
return (nsmlib_errc = NSMECLOSED(-115));
    }
    datalen -= ret;
    recvlen += ret;
  }

  DBGnsmlib_debug("recv 5 recvlen=%d", recvlen);
  /* for data */
  bufp += recvlen;
  recvlen = 0;
  datalen = hp->npar * sizeof(int32_t) + ntohs(hp->len)__bswap_16 (hp->len);
}
DBGnsmlib_debug("recv 6 datalen=%d npar=%d len=%d", datalen, hp->npar, ntohs(hp->len)__bswap_16 (hp->len));
return sizeof(NSMtcphead) + datalen;
977}
978/* -- nsmlib_recvpar ------------------------------------------------- */
979int
980nsmlib_recvpar(NSMcontext *nsmc)
981{
char buf[NSM_TCPMSGSIZ(16 + (256*4 + 65536))];
NSMtcphead *hp = (NSMtcphead *)buf;
int32_t *hp_pars = (int32_t *)(buf + sizeof(NSMtcphead));
int ret = 0;
int val;

DBGnsmlib_debug("recvpar 1");
if (nsmc->usesig > 0) {
  DBGnsmlib_debug("recvpar 2");
  ret = nsmlib_piperead(nsmc, &val);
} else {
  DBGnsmlib_debug("recvpar 3");
  int64 tlimit = time1ms() + 5000; /* 5 seconds */
  int wait_msec = 5000;
  while (1) {
    DBGnsmlib_debug("recvpar 4");
    if ((ret = nsmlib_recv(nsmc, hp, wait_msec)) <= 0) {
if (ret == 0) {
 sprintf(nsmc->errs, "recvpar: timeout");
 ret = NSMETIMEOUTR(-42);
}
break;
    }
    DBGnsmlib_debug("recvpar 5");

    if (ntohs(hp->req)__bswap_16 (hp->req) != nsmc->reqwait) {
DBGnsmlib_debug("recvpar 6 req=%x wait=%x", ntohs(hp->req)__bswap_16 (hp->req), nsmc->reqwait);
if (nsmlib_queue(nsmc, hp) < 0) return -1;
    } else if (hp->npar < 1) {
DBGnsmlib_debug("recvpar 7");
sprintf(nsmc->errs, "recvpar: npar=0 for req=%x", nsmc->reqwait);
ret = NSMEUNEXPECTED(-119);
break;
    } else {
DBGnsmlib_debug("recvpar 8");
val = htonl(hp_pars[0])__bswap_32 (hp_pars[0]);
break;
    }
    wait_msec = (tlimit - time1ms());
  }
}
DBGnsmlib_debug("recvpar 9");
nsmc->reqwait = 0;
if (ret < 0) return nsmc->errc = ret;
if (val < 0) nsmc->errc = val;
return val;
1028}
1029/* -- nsmlib_call ---------------------------------------------------- */
1030void
1031nsmlib_call(NSMcontext *nsmc, NSMtcphead *hp)
1032{
int i;
NSMmsg msg;
const char *recvbuf = (char *)hp + sizeof(NSMtcphead);
NSMrequest *reqp = nsmc->req;
NSMrequest *reqlast = reqp + nsmc->nreq;

DBS(nsmc,1002)nsmlib_checkpoints[nsmlib_currecursive] = (1002);

/* search request */
msg.req = ntohs(hp->req)__bswap_16 (hp->req);
while (reqp < reqlast) {
  if (reqp->functype != NSMLIB_FNNON && reqp->req == msg.req) break;
  reqp++;
}
if (reqp == reqlast) {
  NSMreq *rp = nsmc->sysp->req;
  for (i=0; i<NSMSYS_MAX_REQ1024 && rp[i].name[0]; i++) {
    if (rp[i].code == hp->req) break; // compare without ntohs
  }
  if (i < NSMSYS_MAX_REQ1024 && rp[i].name[0]) {
    LOGnsmlib_lognl("Received request (%s) is not registered", rp[i].name);
  } else {
    LOGnsmlib_lognl("nsmlib_call unknown req=%04x", msg.req);
  }
  for (reqp = nsmc->req; reqp < reqlast; reqp++) {
    DBGnsmlib_debug("reqp[%d] %02x %04x", reqp-nsmc->req, reqp->functype, reqp->req);
  }
  return;
}
if (! reqp->callback && reqp->functype != NSMLIB_FNSYS) {
  DBGnsmlib_debug("nsmlib_call no callback for req=%s", reqp->name);
  return;
}
DBGnsmlib_debug("nsmlib_call req=%s", reqp->name);

DBS(nsmc,1003)nsmlib_checkpoints[nsmlib_currecursive] = (1003);

/* fill other msg entries */
msg.req  = ntohs(hp->req)__bswap_16 (hp->req);
msg.seq  = ntohs(hp->seq)__bswap_16 (hp->seq);
msg.node = ntohs(hp->src)__bswap_16 (hp->src);
msg.npar = hp->npar;
msg.len  = ntohs(hp->len)__bswap_16 (hp->len);
msg.pars[0] = msg.pars[1] = 0; /* to be compatible with NSM1 */
for (i=0; i < msg.npar; i++) {
  msg.pars[i] = ntohl(*(int32_t *)(recvbuf + i*sizeof(int32_t)))__bswap_32 (*(int32_t *)(recvbuf + i*sizeof(int32_t)));
}
msg.datap = msg.len ? recvbuf + msg.npar*sizeof(int32_t) : 0;

DBS(nsmc,1004)nsmlib_checkpoints[nsmlib_currecursive] = (1004);

switch (reqp->functype) {
case NSMLIB_FNSYS:
  if (! reqp->callback) {
    if (nsmc->reqwait != msg.req) {
ASSERTnsmlib_assert("unexpected call %x, waiting for %x", msg.req, nsmc->reqwait);
    }
    nsmc->reqwait = 0;
    DBGnsmlib_debug("pipewrite pars0=%d", msg.pars[0]);
    DBS(nsmc,1006)nsmlib_checkpoints[nsmlib_currecursive] = (1006);
    nsmlib_pipewrite(nsmc, msg.pars[0]);
    DBS(nsmc,1008)nsmlib_checkpoints[nsmlib_currecursive] = (1008);
    break;
  }
  /* no break */

case NSMLIB_FNSTD:
  DBS(nsmc,1010)nsmlib_checkpoints[nsmlib_currecursive] = (1010);
  if (! nsmc->hook) {
    DBGnsmlib_debug("nsmlib_call calling callback without hook");
    DBS(nsmc,1012)nsmlib_checkpoints[nsmlib_currecursive] = (1012);
    reqp->callback(&msg, nsmc);
  } else if (! nsmc->hook(&msg, nsmc)) {
    DBGnsmlib_debug("nsmlib_call calling callback");
    DBS(nsmc,1014)nsmlib_checkpoints[nsmlib_currecursive] = (1014);
    reqp->callback(&msg, nsmc);
  } else {
    DBGnsmlib_debug("nsmlib_call hook error");
  }
  break;

default:
  DBGnsmlib_debug("nsmlib_call functype=%d", reqp->functype);
}
DBS(nsmc,1016)nsmlib_checkpoints[nsmlib_currecursive] = (1016);
1118}
1119/* -- nsmlib_handler ------------------------------------------------- */
1120static void
1121#ifdef SIGRTMIN(__libc_current_sigrtmin ())
1122nsmlib_handler(int sig, siginfo_t *info, void *ignored)
1123#else
1124nsmlib_handler(int sig)
1125#endif
1126{
sigset_t mask;
int wait_msec = 1000; /* 1 sec only for the first time */

/* DBG("nsmlib_handler sig=%d", sig); */

/* sigset */
if (! sig) return; /* this should not be directly called */

/* in the signal handler mode, it can handle more than one signals */
while (1) {
  char buf[NSM_TCPMSGSIZ(16 + (256*4 + 65536))]; /* should not be static */
  NSMcontext *nsmc = nsmlib_selectc(1, wait_msec); /* usesig = 1 */
  wait_msec = 0; /* no wait at the later tries */
  
  if (! nsmc) break;

  /* receive */
  if (nsmlib_recv(nsmc, (NSMtcphead *)buf, 1000) <= 0) { /* 1 sec */
    break;
  }

  /* callback function */
  if (nsmlib_currecursive >= nsmlib_maxrecursive) {
    nsmlib_nskipped++;
    nsmlib_lastskipped = *(NSMtcphead *)buf;
  } else {
    nsmlib_currecursive++;
    DBS(nsmc,1001)nsmlib_checkpoints[nsmlib_currecursive] = (1001);
    sigemptyset(&mask);
    sigaddset(&mask, sig);
    sigprocmask(SIG_UNBLOCK1, &mask, 0);
    nsmlib_call(nsmc, (NSMtcphead *)buf);
    /*sigprocmask(SIG_BLOCK, &mask, 0);*/
    DBS(nsmc,-1)nsmlib_checkpoints[nsmlib_currecursive] = (-1);
    nsmlib_currecursive--;
  }
};

if (nsmlib_logfp && nsmlib_loglen && ! nsmlib_currecursive) {
  nsmlib_logflush();
}

return;
1170}
1171/* -- nsmlib_callbackid ---------------------------------------------- */
1172/*
Calling with callback == 0 will disable the function,
 except for NSMLIB_FNSYS which has no callback.
 Even with callback == 0, it can be used in the non-signal mode.
Calling with existing req  will replace the function in   the list.
Calling with NSMLIB_FNNON  will remove  the function from the list.
System callback functions are protected from removing/replacing.
*/
1180int
1181nsmlib_callbackid(NSMcontext *nsmc, int req, const char *name,
  NSMcallback_t callback, NSMfunctype functype)
1183{
NSMrequest *reqp = nsmc->req;
NSMrequest *reqlast = reqp + nsmc->nreq;
NSMrequest *reqfound = 0;
NSMrequest *reqfree = 0;
int sigfound = 0;

/* basic checks */
if (! nsmc || ! nsmc->memp)         return NSMENOINIT(-26);
if (nsmc->nodeid == NSMSYS_MAX_NOD1024) return NSMEPERM(-27); /* anonymous */

/* search for existing and free-space */
while (reqp < reqlast) {
  if (! reqfree && reqp->functype == NSMLIB_FNNON) {
    reqfree = reqp; /* first free place, but still need to search for req */
  }
  if (reqp->req == req) {
    reqfree = reqfound = reqp;
    if (sigfound) break;
  } else if (reqp->callback) {
    sigfound = 1;
    if (reqfound) break;
  }
  reqp++;
}

/* system function check */
if (nsmc->initsig_done   && functype == NSMLIB_FNSYS) return NSMEINVFUNC(-29);
if (! nsmc->initsig_done && functype != NSMLIB_FNSYS) return NSMEINVFUNC(-29);
if (reqfound  &&  reqfound->functype == NSMLIB_FNSYS) return NSMEINVFUNC(-29);

/* attach to the end if not found */
if (! reqfree) {
  if (nsmc->nreq >= NSMLIB_MAX_CALLBACK1024) return NSMEMAXFUNC(-30);
  reqfree = reqlast;
  nsmc->nreq++;
}

/* update request table */
reqfree->req      = req;
reqfree->functype = functype;
reqfree->callback = callback;
if (name) {
  strcpy(reqfree->name, name);
} else {
  sprintf(reqfree->name, "#%04x", req);
}
return 0;
1231} 
1232/* -- nsmlib_callback ------------------------------------------------ */
1233int
1234nsmlib_callback(NSMcontext *nsmc, const char *name, 
NSMcallback_t callback, NSMfunctype functype)
1236{
NSMsys *sysp = nsmc->sysp;
int hash = nsmlib_hash(sysp, sysp->reqhash, NSMSYS_MAX_HASH2039, name, 0);
NSMreq *reqp = (NSMreq *)MEMPTR(sysp, ntohl(sysp->reqhash[hash]))((char *)(sysp) + __bswap_32 (sysp->reqhash[hash]));

if (hash < 0) {
  nsmc->errc = NSMEUNEXPECTED(-119);
  sprintf(nsmc->errs, "hash error for %s", name);
  return -1;
}

if (strcmp(reqp->name, name)) {
  nsmc->errc = NSMEUNEXPECTED(-119);
  sprintf(nsmc->errs, "wrong hash? name %s %s\n", reqp->name, name);
  return -1;
}
return nsmlib_callbackid(nsmc, ntohs(reqp->code)__bswap_16 (reqp->code), name,
	   callback, functype);
1254}
1255/* -- nsmlib_usesig -------------------------------------------------- */
1256void
1257nsmlib_usesig(NSMcontext *nsmc, int usesig)
1258{
if (nsmc) nsmc->usesig = usesig;
1260}
1261/* -- nsmlib_delclient ----------------------------------------------- */
1262void
1263nsmlib_delclient(NSMmsg *msg, NSMcontext *nsmc)
1264{
LOGnsmlib_lognl("killed by nsmd2");
exit(1);
1267}
1268/* -- nsmlib_initsig ------------------------------------------------- */
1269int
1270nsmlib_initsig(NSMcontext *nsmc)
1271{
struct sigaction action;
int pipes[2];
1274#ifdef SIGRTMIN(__libc_current_sigrtmin ())
void nsmlib_handler(int signo, siginfo_t *info, void *ignored);
nsmlib_sig = SIGRTMIN(__libc_current_sigrtmin ());
1277#define NSMLIB_SETHANDLER(s,h)(s).__sigaction_handler.sa_sigaction=(h); (s).sa_flags = 4|0x10000000 \
(s).sa_sigaction__sigaction_handler.sa_sigaction=(h); (s).sa_flags = SA_SIGINFO4|SA_RESTART0x10000000
1279#else
void nsmlib_handler(int);
nsmlib_sig = SIGUSR110;
1282#define NSMLIB_SETHANDLER(a,h)(a).__sigaction_handler.sa_sigaction=(h); (a).sa_flags = 4|0x10000000 (a).sa_sighandler=(h)
1283#endif

sigemptyset(&nsmlib_sigmask);
sigaddset(&nsmlib_sigmask, nsmlib_sig);

if (! nsmlib_checkpoints) {
  nsmlib_currecursive = 0;
  nsmlib_maxrecursive = NSMLIB_MAXRECURSIVE256;
  nsmlib_nskipped = 0;
  memset(&nsmlib_lastskipped, 0, sizeof(nsmlib_lastskipped));
  nsmlib_checkpoints = nsmlib_malloc(sizeof(int) * nsmlib_maxrecursive,
                                     "initsig", "checkp");
  if (! nsmlib_checkpoints) {
    ASSERTnsmlib_assert("can't alloc %d bytes", sizeof(int) * nsmlib_maxrecursive);
  }
  memset(nsmlib_checkpoints, 0, sizeof(int) * nsmlib_maxrecursive);
}

/* create pipes */
if (pipe(pipes) < 0) {
  nsmc->errn = errno(*__errno_location ());
  return NSMENOPIPE(-111);
}
nsmc->pipe_rd = pipes[0];
nsmc->pipe_wr = pipes[1];

/* setup callback handlers */
nsmlib_callbackid(nsmc, NSMCMD_NEWCLIENT((0xff00) + 0x00), "cmd_newclient", 0, NSMLIB_FNSYS);
nsmlib_callbackid(nsmc, NSMCMD_ALLOCMEM((0xff00) + 0x04),  "cmd_allocmem",  0, NSMLIB_FNSYS);
nsmlib_callbackid(nsmc, NSMCMD_OPENMEM((0xff00) + 0x09),   "cmd_openmem",   0, NSMLIB_FNSYS);
nsmlib_callbackid(nsmc, NSMCMD_FLUSHMEM((0xff00) + 0x06),  "cmd_flushmem",  0, NSMLIB_FNSYS);
nsmlib_callbackid(nsmc, NSMCMD_NEWREQ((0xff00) + 0x18),    "cmd_newreq",    0, NSMLIB_FNSYS);
/* implement delclient as FNSTD */
nsmlib_callbackid(nsmc, NSMCMD_DELCLIENT((0xff00) + 0x03), "cmd_delclient",
    nsmlib_delclient, NSMLIB_FNSYS);
/* ... and many more to follow ----> */

/* setup signals */
memset(&action, 0, sizeof(action));
sigemptyset(&action.sa_mask);
sigaddset(&action.sa_mask, nsmlib_sig);
NSMLIB_SETHANDLER(action, nsmlib_handler)(action).__sigaction_handler.sa_sigaction=(nsmlib_handler); (
action).sa_flags = 4|0x10000000;
/*
  Don't do: action.sa_flags |= SA_RESTART;
  Adding SA_RESTART is not a good idea: a blocking read should
  return with EINTR upon NSM signal, because this NSM signal may be
  the one to clear the blocking condition.
*/
sigaction(nsmlib_sig, &action, 0);

nsmc->usesig = -1; /* undecided */
nsmc->initsig_done = 1;
return 0;
1336}
1337/* -- nsmlib_send ---------------------------------------------------- */
1338int
1339nsmlib_send(NSMcontext *nsmc, NSMmsg *msgp)
1340{
static char buf[NSM_TCPMSGSIZ(16 + (256*4 + 65536))];
NSMtcphead *hp = (NSMtcphead *)buf;
char *datap  = buf + sizeof(NSMtcphead);
const char *writep;
int writelen;
int err = 0;
int i;
int oldsig;

DBS(nsmc,1100)nsmlib_checkpoints[nsmlib_currecursive] = (1100);

if (! nsmc)                         return NSMENOINIT(-26);
if (nsmc->sock < 0)                 return NSMENOINIT(-26);
if (nsmc->nodeid == NSMSYS_MAX_NOD1024) return NSMEPERM(-27); /* anonymous */

if (msgp->len == 0 && msgp->datap != 0)   return NSMEINVDATA(-28);
if (msgp->len == 0 && msgp->datap != 0)   return NSMEINVDATA(-28);

DBS(nsmc,1102)nsmlib_checkpoints[nsmlib_currecursive] = (1102);

DBGnsmlib_debug("nsmlib_send nodeid=%d, req=%04x", msgp->node, msgp->req);

hp->src  = htons(nsmc->nodeid)__bswap_16 (nsmc->nodeid);
hp->dest = htons(msgp->node)__bswap_16 (msgp->node);
hp->req  = htons(msgp->req)__bswap_16 (msgp->req);
hp->seq  = htons(msgp->seq)__bswap_16 (msgp->seq);
hp->npar = msgp->npar;
hp->len  = htons(msgp->len)__bswap_16 (msgp->len);
hp->from = 0;
for (i=0; i<hp->npar; i++) {
  *(int32_t *)datap = htonl(msgp->pars[i])__bswap_32 (msgp->pars[i]);
  datap += sizeof(int32_t);
}
if (msgp->len && msgp->len <= NSM_TCPTHRESHOLD(16 + 256*4)) {
  memcpy(datap, msgp->datap, msgp->len);
  writelen = sizeof(NSMtcphead) + msgp->npar*sizeof(int32_t) + msgp->len;
} else {
  writelen = sizeof(NSMtcphead) + msgp->npar*sizeof(int32_t);
}
writep = buf;

DBS(nsmc,1104)nsmlib_checkpoints[nsmlib_currecursive] = (1104);
DBGnsmlib_debug("writep = %x", writep);

while (writelen > 0) {
  int ret = nsmlib_select(0, nsmc->sock, 1000); /* 1 sec */
  if (ret <  0) { nsmc->errn = errno(*__errno_location ());
                  err = NSMESELECT(-112);   goto nsmlib_send_error; }
  if (ret == 0) { err = NSMETIMEOUTW(-41); goto nsmlib_send_error; }

  ret = write(nsmc->sock, writep, writelen);
  if (ret < 0 && (errno(*__errno_location ()) == EINTR4 || errno(*__errno_location ()) == EAGAIN11)) continue;
  if (ret <  0) { nsmc->errn = errno(*__errno_location ());
                  err = NSMEWRITE(-114);  goto nsmlib_send_error; }
  if (ret == 0) { err = NSMECLOSED(-115); goto nsmlib_send_error; }

  writelen -= ret;
  writep   += ret;
}

if (msgp->len > NSM_TCPTHRESHOLD(16 + 256*4)) {
  writelen = msgp->len;
  writep = msgp->datap;
}

while (writelen > 0) {
  int ret = nsmlib_select(0, nsmc->sock, 1000); /* 1 sec */
  if (ret <  0) { nsmc->errn = errno(*__errno_location ());
                  err = NSMESELECT(-112);   goto nsmlib_send_error; }
  if (ret == 0) { err = NSMETIMEOUTW(-41); goto nsmlib_send_error; }

  ret = write(nsmc->sock, writep, writelen);
  if (ret < 0 && (errno(*__errno_location ()) == EINTR4 || errno(*__errno_location ()) == EAGAIN11)) continue;
  if (ret <  0) { nsmc->errn = errno(*__errno_location ());
                  err = NSMEWRITE(-114);  goto nsmlib_send_error; }
  if (ret == 0) { err = NSMECLOSED(-115); goto nsmlib_send_error; }

  writelen -= ret;
  writep   += ret;
}
DBS(nsmc,1106)nsmlib_checkpoints[nsmlib_currecursive] = (1106);
return 0;

nsmlib_send_error:
DBS(nsmc,1199)nsmlib_checkpoints[nsmlib_currecursive] = (1199);
shutdown(nsmc->sock, SHUT_RDWRSHUT_RDWR);
close(nsmc->sock);
nsmc->sock = -1;
return err; /* nsmc->errc or nsmlib_errc is set in the caller */
1430}
1431/* -- nsmlib_initcli ------------------------------------------------- */
1432static int
1433nsmlib_initcli(NSMcontext *nsmc, const char *nodename)
1434{
NSMsys *sysp = nsmc->sysp;
NSMmsg msg;
int ret;
int inod;
int force_newclient = 0;

/* check if the node is already there */
int nnod = (int16_t)ntohs(sysp->nnod)__bswap_16 (sysp->nnod);
for (inod = 0; inod <= nnod; inod++) {
18
←
Assuming 'inod' is <= 'nnod'→
19
←
Loop condition is true.  Entering loop body→
  NSMnod *nodp = &sysp->nod[inod];
  if (strcmp(nodp->name, nodename) != 0) continue;
20
←
Null pointer passed to 2nd parameter expecting 'nonnull'
  if (nodp->ipaddr != sysp->ipaddr) continue;
  if (kill(ntohl(nodp->nodpid)__bswap_32 (nodp->nodpid), 0) == 0 || errno(*__errno_location ()) != ESRCH3) {
    sprintf(nsmlib_errs, "node %s already exists", nodename);
    return nsmlib_errc = NSMENODEEXIST(-4);
  }
  force_newclient = 1;
  break;
}

/* request setup */
memset(&msg, 0, sizeof(msg));
msg.node = -1;
msg.pars[0] = geteuid();
msg.pars[1] = getpid();
msg.pars[2] = NSM_LIBRARY_VERSION2008;
msg.npar    = 3;
if (force_newclient) {
  msg.npar = 4;
  msg.pars[3] = 0; /* value itself is unused */
}
msg.datap   = nodename;
if (nodename) msg.len = strlen(nodename) + 1;
1468#ifdef SIGRTMIN(__libc_current_sigrtmin ())
msg.req = NSMCMD_NEWCLIENT((0xff00) + 0x00);
1470#else
msg.req = NSMCMD_NEWCLIENTOB((0xff00) + 0x01); /* obsolete */
1472#endif

/* send request */
nsmc->reqwait = msg.req;
if ((ret = nsmlib_send(nsmc, &msg)) < 0) {
  nsmc->reqwait = 0;
  return nsmlib_errc = ret;
}

/* receive request */
ret = nsmlib_recvpar(nsmc);
DBGnsmlib_debug("initcli: recvpar=%d", ret);
if (ret < 0) {
  switch (ret) {
  case NSMENODEEXIST(-4):
  case NSMENODEHERE(-45):
    sprintf(nsmlib_errs, "node %s already exists", nodename);
    break;
  case NSMEFULNODE(-5):
    sprintf(nsmlib_errs, "no more place for node %s", nodename);
    break;
  default:
    /* errs just in case when errc is unknown */
    sprintf(nsmlib_errs, "initcli: recvpar error=%d", ret);
  }
  return nsmlib_errc = ret;
}
if (ret > NSMSYS_MAX_NOD1024) {
  sprintf(nsmlib_errs, "invalid nodeid=%d returned from nsmd2", ret);
  return nsmlib_errc = NSMEUNEXPECTED(-119);
}
nsmc->nodeid = ret;
return 0;
1505}
1506/* -- nsmlib_sendreqid ----------------------------------------------- */
1507int
1508nsmlib_sendreqid(NSMcontext *nsmc,
 const char *node, uint16_t req, uint npar, int *pars,
 int len, const char *datap)
1511{
NSMmsg msg;
int i;
int nodeid;

if (! nsmc || ! nsmc->memp)  return NSMENOINIT(-26);

if (! node || ! *node) return nsmc->errc = NSMEEMPTYDEST(-39);
nodeid = nsmlib_nodeid(nsmc, node);
if (nodeid < 0) return nsmc->errc = NSMENODEST(-6);

msg.req = req;
msg.seq = nsmc->seq++;
msg.node = (uint16_t)nodeid;
msg.npar = npar > 256 ? 0 : npar;
for (i=0; i<msg.npar; i++) msg.pars[i] = pars[i];
msg.len = len;
msg.datap = datap;
return (nsmc->errc = nsmlib_send(nsmc, &msg));
1530}
1531/* -- nsmlib_reqid --------------------------------------------------- */
1532int
1533nsmlib_reqid(NSMcontext *nsmc, const char *reqname)
1534{
NSMsys *sysp = nsmc->sysp;
int hash = nsmlib_hash(sysp, sysp->reqhash, NSMSYS_MAX_HASH2039, reqname, 0);
NSMreq *reqp = (NSMreq *)MEMPTR(sysp, ntohl(sysp->reqhash[hash]))((char *)(sysp) + __bswap_32 (sysp->reqhash[hash]));

if (hash < 0) {
  sprintf(nsmlib_errs, "reqid: req %s is unknown", reqname);
  return NSMENOSUCHREQ(-43);
}

if (strcmp(reqp->name, reqname)) {
  sprintf(nsmlib_errs,
          "broken hash-table for req %s => %s\n", reqname, reqp->name);
  return NSMEBADHASH(-44);
}
return ntohs(reqp->code)__bswap_16 (reqp->code);
1550}
1551/* -- nsmlib_reqname ------------------------------------------------- */
1552const char *
1553nsmlib_reqname(NSMcontext *nsmc, int reqid)
1554{
NSMsys *sysp = nsmc->sysp;
reqid -= NSMREQ_FIRST(0x1000);
if (reqid < 0 || reqid >= NSMSYS_MAX_REQ1024) return "(invalid)";
if (! sysp->req[reqid].name[0]) return "(undef)";
return sysp->req[reqid].name;
1560}
1561/* -- nsmlib_sendreq ------------------------------------------------- */
1562int
1563nsmlib_sendreq(NSMcontext *nsmc, const char *node, const char *req,
      uint npar, int *pars, int len, const char *datap)
1565{
int reqid = nsmlib_reqid(nsmc, req);
if (reqid < 0) {
  sleep(1); /* one second penalty */
  return reqid;
}
return nsmlib_sendreqid(nsmc, node, reqid, npar, pars, len, datap);
1572}
1573/* -- nsmlib_register_request ---------------------------------------- */
1574int
1575nsmlib_register_request(NSMcontext *nsmc, const char *name)
1576{
NSMmsg msg;
int ret;
int reqid;
memset(&msg, 0, sizeof(msg));
msg.req   = NSMCMD_NEWREQ((0xff00) + 0x18);
msg.node  = -1;
msg.len   = strlen(name) + 1;
msg.datap = name;
nsmc->reqwait = msg.req;

/* send request */
DBGnsmlib_debug("register_request: before send");
nsmc->errc = nsmlib_send(nsmc, &msg);
DBGnsmlib_debug("register_request: after send");
if (nsmc->errc < 0) { nsmc->reqwait = 0; return nsmc->errc; }

/* receive request */
DBGnsmlib_debug("register_request: before recvpar");
ret = nsmlib_recvpar(nsmc);
DBGnsmlib_debug("register_request: after recvpar");
if (ret < 0) return ret;
return 0;
1599}
1600/* -- nsmlib_readmem ------------------------------------------------- */
1601int
1602nsmlib_readmem(NSMcontext *nsmc, void *buf,
      const char *datname, const char *fmtname, int revision)
1604{
char fmtstr[256];
NSMsys *sysp = nsmc->sysp;
NSMmem *memp = nsmc->memp;
NSMmsg msg;
int ret;
int datid;
NSMdat *datp;
int newrevision = -1;

if (! fmtname) fmtname = datname;

if (revision <= 0 && revision != -1) {
  sprintf(nsmc->errs, "invalid revision %d for data %s", revision, datname);
  return nsmc->errc = NSMEINVPAR(-3);
}
NSMparse *parsep = nsmlib_parsefile(fmtname, revision, nsmlib_incpath,
                                    fmtstr, &newrevision);
if (! parsep) {
  int errcode;
  const char *errstr = nsmlib_parseerr(&errcode);
  sprintf(nsmc->errs, "cannot read data %s, %s", datname, errstr);
  return nsmc->errc = NSMEPARSE(-34);
}
nsmlib_parsefree(parsep);
parsep = 0;

if (revision == -1) {
  revision = newrevision;
}

/* linear search, to be replaced with a hash version */
for (datid = 0; datid < NSMSYS_MAX_DAT1024; datid++) {
  datp = sysp->dat + datid;
  if (strcmp(datp->dtnam, datname) == 0) break;
}
if (datid == NSMSYS_MAX_DAT1024) {
  sprintf(nsmc->errs, "data %s not found", datname);
  return nsmc->errc = NSMENOMEM(-31);
}
if (strcmp(datp->dtfmt, fmtstr) != 0) {
  sprintf(nsmc->errs, "data %s format mismatch %s %s",
   datname, fmtstr, datp->dtfmt);
  return nsmc->errc = NSMEBADFMT(-32);
}
if (ntohs(datp->dtrev)__bswap_16 (datp->dtrev) != revision) {
  sprintf(nsmc->errs, "data %s revision mismatch %d %d",
          datname, revision, datp->dtrev);
  return nsmc->errc = NSMEBADREV(-33);
}

memcpy((char *)buf, 
(char *)memp + ntohl(datp->dtpos)__bswap_32 (datp->dtpos), ntohs(datp->dtsiz)__bswap_16 (datp->dtsiz));

return 0;
1659}
1660/* -- nsmlib_statmem ------------------------------------------------ */
1661/*
return value: size of data if > 0
fmtbuf is set with name of struct
1664*/
1665int
1666nsmlib_statmem(NSMcontext *nsmc,
             const char *datname, char *fmtbuf, int bufsiz)
1668{
NSMsys *sysp = nsmc->sysp;
NSMdat *datp;
int datid;
int dtfmtlen;

if (! fmtbuf) return 0;
  
/* linear search, to be replaced with a hash version */
for (datid = 0; datid < NSMSYS_MAX_DAT1024; datid++) {
  datp = sysp->dat + datid;
  if (strcmp(datp->dtnam, datname) == 0) break;
}
if (datid == NSMSYS_MAX_DAT1024) {
  sprintf(nsmc->errs, "data %s not found", datname);
  return (nsmc->errc = NSMENOMEM(-31));
}

dtfmtlen = strlen(datp->dtfmt);
*fmtbuf = 0;
if (datp->dtfmt[dtfmtlen + 1]) {
  int dtstrlen = strlen(datp->dtfmt + dtfmtlen + 1);
  if (dtstrlen < bufsiz) {
    strcpy(fmtbuf, datp->dtfmt + dtfmtlen + 1);
  }
}
return (int)ntohs(datp->dtsiz)__bswap_16 (datp->dtsiz);
1695}
1696/* -- nsmlib_openmem ------------------------------------------------- */
1697void *
1698nsmlib_openmem(NSMcontext *nsmc,
      const char *datname, const char *fmtname, int revision)
1700{
char fmtstr[256];
NSMsys *sysp = nsmc->sysp;
NSMmem *memp = nsmc->memp;
NSMmsg msg;
int ret;
int datid;
NSMdat *datp;
int refid;
NSMref *refp;
int newrevision = -1;

if (! fmtname) fmtname = datname;

if (revision <= 0 && revision != -1) {
  sprintf(nsmc->errs, "invalid revision %d for data %s", revision, datname);
  nsmc->errc = NSMEINVPAR(-3);
  return 0;
}
NSMparse *parsep = nsmlib_parsefile(fmtname, revision, nsmlib_incpath,
                                    fmtstr, &newrevision);
if (! parsep) {
  int errcode;
  const char *errstr = nsmlib_parseerr(&errcode);
  sprintf(nsmc->errs, "cannot open data %s, %s", datname, errstr);
  nsmc->errc = NSMEPARSE(-34);
  return 0;
}
nsmlib_parsefree(parsep);
  
if (revision == -1) {
  revision = newrevision;
}

/* linear search, to be replaced with a hash version */
for (datid = 0; datid < NSMSYS_MAX_DAT1024; datid++) {
  datp = sysp->dat + datid;
  if (strcmp(datp->dtnam, datname) == 0) break;
}
if (datid == NSMSYS_MAX_DAT1024) {
  sprintf(nsmc->errs, "data %s not found", datname);
  nsmc->errc = NSMENOMEM(-31);
  return 0;
}
if (strcmp(datp->dtfmt, fmtstr) != 0) {
  sprintf(nsmc->errs, "data %s format mismatch %s %s",
   datname, fmtstr, datp->dtfmt);
  nsmc->errc = NSMEBADFMT(-32);
  return 0;
}
if (ntohs(datp->dtrev)__bswap_16 (datp->dtrev) != revision) {
  sprintf(nsmc->errs, "data %s revision mismatch %d %d\n",
          datname, revision, datp->dtrev);
  nsmc->errc = NSMEBADREV(-33);
  return 0;
}

/* check locally before asking nsmd2 */
for (refid = 0; refid < NSMSYS_MAX_REF4096; refid++) {
  NSMref *refp = sysp->ref + refid;
  if (ntohs(refp->refdat)__bswap_16 (refp->refdat) == datid &&
      ntohs(refp->refnod)__bswap_16 (refp->refnod) == nsmc->nodeid) {
    /* 2018.0709.0438 local check newly added -- test to check if works
       printf("nsmlib_openmem: already opened at %p\n",
       (char *)memp + ntohl(datp->dtpos));
    */
    sleep(1); /* one second penalty */
    nsmc->errc = NSMEOPENED(-10);
    return 0;
  }
}

/* ask nsmd2 to open */
memset(&msg, 0, sizeof(msg));
msg.req = NSMCMD_OPENMEM((0xff00) + 0x09);
msg.node = -1;
msg.npar = 1;
msg.pars[0] = datid;
nsmc->reqwait = msg.req;
if ((nsmc->errc = nsmlib_send(nsmc, &msg)) < 0) {
  nsmc->reqwait = 0;
  return 0;
}
if ((ret = nsmlib_recvpar(nsmc)) < 0) {
  sleep(1); /* one second penalty */
  return 0;
}
if (ret != datp - sysp->dat) {
  sprintf(nsmc->errs, "datid mismatch %d %d", ret, (int)(datp - sysp->dat));
  nsmc->errc = NSMEDATID(-118);
  return 0;
}
return (char *)memp + ntohl(datp->dtpos)__bswap_32 (datp->dtpos);
1793}
1794/* -- nsmlib_flushmem ------------------------------------------------ */
1795int
1796nsmlib_flushmem(NSMcontext *nsmc, const void *ptr, int psiz)
1797{
NSMmsg msg;
NSMsys *sysp;
size_t ppos;
size_t dpos = 0;
size_t dsiz = 0;
int nnext;
int n = 0; /* to check inf-loop */
int ret;

if (! nsmc || nsmc->nodeid < 0 || nsmc->nodeid >= NSMSYS_MAX_NOD1024) {
  return NSMENOINIT(-26);
}

if (! (sysp = nsmc->sysp) || ! nsmc->memp) {
  return nsmc->errc = NSMENOINIT(-26);
}

ppos = MEMPOS(nsmc->memp, ptr)((char *)(ptr) - (char *)(nsmc->memp));
if (psiz < 0 || ppos < 0 || ppos >= NSM2_MEMSIZ(4096*1024) || ppos+psiz > NSM2_MEMSIZ(4096*1024)) {
  DBGnsmlib_debug("flushmem(invptr): psiz=%d ppos=%d", (int)psiz, (int)ppos);
  return nsmc->errc = NSMEINVPTR(-36);
}

/* linked list search (only through owned data) */
nnext = (int16_t)ntohs(sysp->nod[nsmc->nodeid].noddat)__bswap_16 (sysp->nod[nsmc->nodeid].noddat);
while (nnext >= 0 && nnext < NSMSYS_MAX_DAT1024) {
  NSMdat *datp = sysp->dat + nnext;
  dpos = (int32_t)ntohl(datp->dtpos)__bswap_32 (datp->dtpos);
  dsiz = (int16_t)ntohs(datp->dtsiz)__bswap_16 (datp->dtsiz);
  DBGnsmlib_debug("flushmem: ppos=%d dpos=%d ppos+psiz=%d dpos+dsiz=%d",
      (int)ppos, (int)dpos, (int)(ppos+psiz), (int)(dpos+dsiz));
  if (ppos == dpos && psiz == 0) psiz = dsiz;
  if (ppos >= dpos && ppos+psiz <= dpos+dsiz) break;
  
  nnext = (int16_t)ntohs(datp->nnext)__bswap_16 (datp->nnext);
  if (++n > NSMSYS_MAX_DAT1024) nnext = -1; /* avoid inf-loop by broken nnext */
}
if (nnext < 0 || nnext >= NSMSYS_MAX_DAT1024) {
  sprintf(nsmc->errs, "data not found for pos=%d siz=%d",
          (int)ppos, (int)psiz);
  return nsmc->errc = NSMENOMEM(-31); /* end of linked list or error */
}

/* send it */
memset(&msg, 0, sizeof(msg));
msg.req = NSMCMD_FLUSHMEM((0xff00) + 0x06);
msg.node = -1; /* no particular destination */
msg.npar = 2;
msg.pars[0] = ppos;
msg.pars[1] = psiz;
DBGnsmlib_debug("flushmem: psiz=%d ppos=%d", (int)psiz, (int)ppos);
nsmc->reqwait = msg.req;
nsmc->errc = nsmlib_send(nsmc, &msg);
if (nsmc->errc < 0) {
  nsmc->reqwait = 0;
  return 0;
}

/* receive response */
ret = nsmlib_recvpar(nsmc);
nsmc->reqwait = 0;
return ret;
1860}
1861/* -- nsmlib_allocmem ------------------------------------------------ */
1862void *
1863nsmlib_allocmem(NSMcontext *nsmc, const char *datname, const char *fmtname,
int revision, float cycle)
1865{
NSMmsg msg;
int ret;
int reqid;
char fmtstr[256];
char *p;
NSMsys *sysp = nsmc->sysp;
NSMmem *memp = nsmc->memp;
int newrevision = -1;

DBGnsmlib_debug("allocmem 1");

if (! fmtname) fmtname = datname;
if (! nsmc) { nsmlib_errc = NSMENOINIT(-26); return 0; }
if (! datname) { nsmc->errc = NSMEINVPAR(-3); return 0; }
if (revision <= 0) { nsmc->errc = NSMEINVPAR(-3); return 0; }
if (strlen(datname) > NSMSYS_DNAM_SIZ31) { nsmc->errc = NSMEINVPAR(-3); return 0; }

NSMparse *parsep = nsmlib_parsefile(fmtname, revision, nsmlib_incpath,
                                    fmtstr, &newrevision);
if (! (parsep)) {
  int errcode;
  const char *errstr = nsmlib_parseerr(&errcode);
  sprintf(nsmc->errs, "cannot allocate data %s, %s", datname, errstr);
  nsmc->errc = NSMEPARSE(-34);
  return 0;
}
nsmlib_parsefree(parsep);

if (revision != newrevision) {
  sprintf(nsmc->errs, "data revision mismatch for %s, %d != %d",
          datname, revision, newrevision);
  nsmc->errc = NSMEPARSE(-34);
  return 0;
}
if (strlen(fmtstr) + strlen(fmtname) + 1 > NSMSYS_DFMT_SIZ63) {
  nsmc->errc = NSMEINVPAR(-3);
  return 0;
}
if (! (p = nsmlib_malloc(strlen(datname) + strlen(fmtstr) +
                         strlen(fmtname) + 3, "allocmem", datname))) {
  nsmc->errc = NSMEALLOC(-101);
  return 0;
}

sprintf(p, "%s %s %s", datname, fmtstr, fmtname);

memset(&msg, 0, sizeof(msg));
msg.req = NSMCMD_ALLOCMEM((0xff00) + 0x04);
msg.node = -1;
msg.npar = 2;
msg.pars[0] = (cycle != 0) ? (int)(cycle * 100) : 500; /* in 10ms unit */
msg.pars[1] = revision;
msg.len = strlen(p) + 1;
msg.datap = p;
DBGnsmlib_debug("datap=%s\n", p);
nsmc->reqwait = msg.req;
nsmc->errc = nsmlib_send(nsmc, &msg);
nsmlib_free(p);
if (nsmc->errc < 0) {
  nsmc->reqwait = 0;
  return 0;
}
DBGnsmlib_debug("allocmem 2");
ret = nsmlib_recvpar(nsmc);
DBGnsmlib_debug("allocmem 3");
nsmc->reqwait = 0;
if (ret < 0) return 0;
DBGnsmlib_debug("allocmem: ret=%d dtpos=%d\n", ret, ntohl(sysp->dat[ret].dtpos)__bswap_32 (sysp->dat[ret].dtpos));
p = (char *)memp + ntohl(sysp->dat[ret].dtpos)__bswap_32 (sysp->dat[ret].dtpos);
return p;
1936}
1937/* -- nsmlib_shutdown --------------------------------------------------- */
1938static int
1939nsmlib_shutdown(NSMcontext *nsmc, int ret, int port)
1940{
if (! nsmlib_context && nsmlib_checkpoints) {
  nsmlib_free(nsmlib_checkpoints);
  nsmlib_checkpoints = 0;
}
if (nsmc->sock >= 0) {
  shutdown(nsmc->sock, SHUT_RDWRSHUT_RDWR);
  close(nsmc->sock);
}
if (nsmc->pipe_rd >= 0) close(nsmc->pipe_rd);
if (nsmc->pipe_wr >= 0) close(nsmc->pipe_wr);
if (nsmc->sysp) shmdt(nsmc->sysp);
if (nsmc->memp) shmdt(nsmc->memp);
  
nsmlib_errc = ret;
nsmlib_port = port;
nsmlib_free(nsmc);
nsmc = 0;
sleep(1); /* one second penalty */
1959}
1960/* -- nsmlib_init ------------------------------------------------------- */
1961/*    node is anonymous when nodename = 0                                 */
1962/*                                                                        */
1963/*    since nsm-1931 IP address for TCP connection is taken from the      */
1964/*    shared memory and there is no use for the "host" variable nor       */
1965/*    NSM2_HOST environment variable.                                     */
1966/*                                                                        */
1967/* ---------------------------------------------------------------------- */
1968NSMcontext *
1969nsmlib_init(const char *nodename, const char *unused, int port, int shmkey)
1970{
NSMcontext *nsmc;
int ret = 0;
int i;

if (! nsmlib_logfp) nsmlib_logfp = stdoutstdout;
1
Assuming 'nsmlib_logfp' is non-null→
2
←
Taking false branch→

/* if (! nodename || strlen(nodename) > NSMSYS_NAME_SIZ) ret = -1; */
if (nodename) {
3
←
Assuming 'nodename' is null→
4
←
Taking false branch→
  if (! *nodename) ret = -1;
  if (strlen(nodename) > NSMSYS_NAME_SIZ31) ret = -1;
  for (i=0; ret == 0 && nodename[i]; i++) {
    if (! isalnum(nodename[i])((*__ctype_b_loc ())[(int) ((nodename[i]))] & (unsigned short
 int) _ISalnum) && nodename[i] != '_') ret = -1;
  }
}
if (ret4.1
'ret' is >= 0
 < 0) {
5
←
Taking false branch→
  nsmlib_errc = NSMENODENAME(-11);
  sleep(1); /* one second penalty */
  return 0;
}

if (! (nsmc = nsmlib_malloc(sizeof(*nsmc), "init", "nsmc"))) {
6
←
Assuming 'nsmc' is non-null→
7
←
Taking false branch→
  nsmlib_errc = NSMEALLOC(-101);
  sleep(1); /* one second penalty */
  return 0;
}

/* -- set up nsm context -- */
memset(nsmc, 0, sizeof(*nsmc));
strcpy(nsmc->nodename, nodename7.1
'nodename' is null
 ? nodename : "(anonymous)");
8
←
'?' condition is false→
nsmc->pipe_rd = -1;
nsmc->pipe_wr = -1;
nsmc->sock = -1;

/* -- environment variables -- */
if (! port)   port   = nsmlib_atoi(getenv(NSMENV_PORT"NSM2_PORT"), NSM2_PORT8120);
9
←
Assuming 'port' is not equal to 0→
10
←
Taking false branch→

/* -- shared memory initialization -- */
if (ret10.1
'ret' is equal to 0
 == 0) ret = nsmlib_initshm(nsmc, shmkey, port);
11
←
Taking true branch→

/* -- network initialization -- */
if (ret11.1
'ret' is equal to 0
 == 0) ret = nsmlib_initnet(nsmc, 0, port);
12
←
Taking true branch→

/* -- signal handler initialization -- */
if (ret == 0) ret = nsmlib_initsig(nsmc);
13
←
Assuming 'ret' is equal to 0→
14
←
Taking true branch→

/* -- client initialization -- */
if (ret14.1
'ret' is equal to 0
 == 0) ret = nsmlib_initcli(nsmc, nodename);
15
←
Taking true branch→
16
←
Passing null pointer value via 2nd parameter 'nodename'→
17
←
Calling 'nsmlib_initcli'→

/* -- nsm context -- */
if (ret == 0) {
  nsmc->next = nsmlib_context;
  nsmlib_context = nsmc;    /* -- insert at the top -- */
} else {
  nsmlib_shutdown(nsmc, ret, port);
  nsmc = 0;
}

return nsmc;
2029}
2030/* -- nsmlib_term ------------------------------------------------------- */
2031int
2032nsmlib_term(NSMcontext *nsmc)
2033{
NSMcontext *c = nsmlib_context;
if (! nsmc) return 0;
if (! c)    return NSMEUNEXPECTED(-119);

/* -- remove nsmc from linked-list of contexts -- */
if (nsmc == c) {
  nsmlib_context = c->next;
} else {
  int found = 0;
  while (c->next) {
    if (nsmc == c->next) {
      c->next = c->next->next;
      found = 1;
      break;
    }
    c = c->next;
  }
  if (! found) return NSMEUNEXPECTED(-119);
}

nsmlib_shutdown(nsmc, 0, 0);
return 0;
2056}
2057/* -- (emacs outline mode setup) ------------------------------------- */
2058/*
2059// Local Variables: ***
2060// mode:outline-minor ***
2061// outline-regexp:"^/\\* --[+ ]" ***
2062// End: ***
2063*/