| File: | daq/slc/nsm2/b2lib/belle2nsm.c |
| Warning: | line 377, column 5 Value stored to 'str' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
| 1 | /************************************************************************** |
| 2 | * basf2 (Belle II Analysis Software Framework) * |
| 3 | * Author: The Belle II Collaboration * |
| 4 | * * |
| 5 | * See git log for contributors and copyright holders. * |
| 6 | * This file is licensed under LGPL-3.0, see LICENSE.md. * |
| 7 | **************************************************************************/ |
| 8 | /* ---------------------------------------------------------------------- *\ |
| 9 | belle2nsm.c |
| 10 | |
| 11 | NSM client library for Belle II experiment, including definitions of |
| 12 | Belle II specific message definitions. All lower level functions of |
| 13 | nsmlib2.c are encapsulated in belle2nsm.c. |
| 14 | |
| 15 | All external library functions have prefix "b2nsm_". |
| 16 | |
| 17 | 20131230 1918 strerror fix, initnet fix, stdint fix, bridge fix |
| 18 | 20140103 1919 more text into log for b2nsm_ok |
| 19 | 20140106 1921 wrapptr added |
| 20 | 20140124 1925 anonymous node, forgotten uprcase in openmem |
| 21 | 20140305 1927 allow null state in b2nsm_ok |
| 22 | 20140305 1929 checkpoints, no fprintf |
| 23 | 20140306 1930 logfp again, but write instead of fwrite/fprintf |
| 24 | 20140902 1935 memset fix |
| 25 | 20140921 1940 flushmem |
| 26 | 20160420 1946 debugflag separately from corelib |
| 27 | 20180121 1957 b2nsm_nodename is added |
| 28 | 20180709 1974 b2nsm_reqid is added |
| 29 | 20180709 1975 one more layer of wrapptr |
| 30 | 20180912 1990 logflush also at the end of sendany |
| 31 | 20180926 1990 b2nsm_reqname is added, uprcase fix in b2nsm_callback |
| 32 | 20181126 1994 b2nsm_nodeproc is added |
| 33 | 20190913 1999 b2nsm_logging and b2nsm_context return previous value |
| 34 | 20191002 1999 avoid nsmsys2.h as much as possible |
| 35 | \* ---------------------------------------------------------------------- */ |
| 36 | |
| 37 | const char *belle2nsm_version = "belle2nsm 1.9.99"; |
| 38 | |
| 39 | #include <stdio.h> |
| 40 | #include <stdlib.h> |
| 41 | #include <stdarg.h> |
| 42 | #include <string.h> |
| 43 | #include <ctype.h> |
| 44 | #include <time.h> |
| 45 | #include <sys/time.h> |
| 46 | |
| 47 | #include "nsm2/nsm2.h" |
| 48 | #include "nsm2/nsmsys2.h" |
| 49 | /* NSM_TCPMSGSIZ is the only unavoidable dependence to nsmsys2.h |
| 50 | from belle2nsm.c */ |
| 51 | #include "nsm2/nsmlib2.h" |
| 52 | #include "nsm2/belle2nsm.h" |
| 53 | |
| 54 | /* checkpoint of signal handler to be studied with gdb |
| 55 | 0: never called, -1: done, 1..1000 user checkpoint, 1001.. corelib/b2lib |
| 56 | */ |
| 57 | extern int nsmlib_currecursive; |
| 58 | #define DBS(nsmc,val)nsmlib_checkpoint(0,val) nsmlib_checkpoint(0,val) |
| 59 | #define DBGFLG(i)(b2nsm_debugflag&(1<<(i))) (b2nsm_debugflag&(1<<(i))) |
| 60 | |
| 61 | NSMcontext *nsm = 0; |
| 62 | static int b2nsm_errc; |
| 63 | FILE *logfp = 0; |
| 64 | static int b2nsm_debugflag = 0; |
| 65 | |
| 66 | typedef struct b2nsm_struct { |
| 67 | void *wrapptr; |
| 68 | char default_dest[32]; |
| 69 | char state[32]; |
| 70 | } b2nsm_t; |
| 71 | |
| 72 | /* -- xuprcpy ----------------------------------------------------------- */ |
| 73 | static void |
| 74 | xuprcpy(char *upr, const char *str, int n) |
| 75 | { |
| 76 | int i; |
| 77 | for (i=0; i<n-1 && str[i]; i++) upr[i] = toupper(str[i])(__extension__ ({ int __res; if (sizeof (str[i]) > 1) { if (__builtin_constant_p (str[i])) { int __c = (str[i]); __res = __c < -128 || __c > 255 ? __c : (*__ctype_toupper_loc ( ))[__c]; } else __res = toupper (str[i]); } else __res = (*__ctype_toupper_loc ())[(int) (str[i])]; __res; })); |
| 78 | upr[i] = 0; |
| 79 | } |
| 80 | /* -- xlogtime ---------------------------------------------------------- */ |
| 81 | static const char * |
| 82 | xt() |
| 83 | { |
| 84 | struct timeval now; |
| 85 | struct tm *cur; |
| 86 | static char buf[32]; |
| 87 | gettimeofday(&now, 0); |
| 88 | cur = localtime((time_t *)&now.tv_sec); |
| 89 | sprintf(buf, "%02d:%02d:%02d.%03d ", |
| 90 | cur->tm_hour, cur->tm_min, cur->tm_sec, (int)now.tv_usec/1000); |
| 91 | return buf; |
| 92 | } |
| 93 | /* -- b2nsm_getwrapptr -------------------------------------------------- */ |
| 94 | /* since wrapptr is already used by b2nsm, one more wrapping is needed */ |
| 95 | void * |
| 96 | b2nsm_getwrapptr() |
| 97 | { |
| 98 | if (! nsm) return 0; |
| 99 | if (! nsm->wrapptr) return 0; |
| 100 | |
| 101 | return ((b2nsm_t *)nsm->wrapptr)->wrapptr; |
| 102 | } |
| 103 | /* -- b2nsm_setwrapptr -------------------------------------------------- */ |
| 104 | int |
| 105 | b2nsm_setwrapptr(void *ptr) |
| 106 | { |
| 107 | if (! nsm) return -1; |
| 108 | if (! nsm->wrapptr) return -1; |
| 109 | ((b2nsm_t *)nsm->wrapptr)->wrapptr = ptr; |
| 110 | return 1; |
| 111 | } |
| 112 | /* -- b2nsm_addincpath -------------------------------------------------- */ |
| 113 | int |
| 114 | b2nsm_addincpath(const char *path) |
| 115 | { |
| 116 | return nsmlib_addincpath(path); |
| 117 | } |
| 118 | /* -- b2nsm_nodename ---------------------------------------------------- */ |
| 119 | const char * |
| 120 | b2nsm_nodename(int nodeid) |
| 121 | { |
| 122 | return nsmlib_nodename(nsm, nodeid); |
| 123 | } |
| 124 | /* -- b2nsm_nodeid ------------------------------------------------------ */ |
| 125 | int |
| 126 | b2nsm_nodeid(const char *nodename) |
| 127 | { |
| 128 | char nodename_uprcase[NSMSYS_NAME_SIZ31 + 1]; |
| 129 | xuprcpy(nodename_uprcase, nodename, NSMSYS_NAME_SIZ31 + 1); |
| 130 | return nsmlib_nodeid(nsm, nodename_uprcase); |
| 131 | } |
| 132 | /* -- b2nsm_nodepid ----------------------------------------------------- */ |
| 133 | int |
| 134 | b2nsm_nodepid(const char *nodename) |
| 135 | { |
| 136 | char nodename_uprcase[NSMSYS_NAME_SIZ31 + 1]; |
| 137 | xuprcpy(nodename_uprcase, nodename, NSMSYS_NAME_SIZ31 + 1); |
| 138 | return nsmlib_nodepid(nsm, nodename_uprcase); |
| 139 | } |
| 140 | /* -- b2nsm_nodeproc ---------------------------------------------------- */ |
| 141 | int |
| 142 | b2nsm_nodeproc(const char *nodename) |
| 143 | { |
| 144 | char nodename_uprcase[NSMSYS_NAME_SIZ31 + 1]; |
| 145 | xuprcpy(nodename_uprcase, nodename, NSMSYS_NAME_SIZ31 + 1); |
| 146 | return nsmlib_nodeproc(nsm, nodename_uprcase); |
| 147 | } |
| 148 | /* -- b2nsm_reqname ----------------------------------------------------- */ |
| 149 | const char * |
| 150 | b2nsm_reqname(int reqid) |
| 151 | { |
| 152 | return nsmlib_reqname(nsm, reqid); |
| 153 | } |
| 154 | /* -- b2nsm_reqid ------------------------------------------------------- */ |
| 155 | int |
| 156 | b2nsm_reqid(const char *reqname) |
| 157 | { |
| 158 | char reqname_uprcase[NSMSYS_NAME_SIZ31 + 1]; |
| 159 | xuprcpy(reqname_uprcase, reqname, NSMSYS_NAME_SIZ31 + 1); |
| 160 | return nsmlib_reqid(nsm, reqname_uprcase); |
| 161 | } |
| 162 | /* -- b2nsm_loghook ----------------------------------------------------- */ |
| 163 | int |
| 164 | b2nsm_loghook(NSMmsg *msg, NSMcontext *nsmc) |
| 165 | { |
| 166 | DBS(nsmc,2000)nsmlib_checkpoint(0,2000); |
| 167 | |
| 168 | if (logfp && DBGFLG(0)(b2nsm_debugflag&(1<<(0)))) { |
| 169 | int i; |
| 170 | int npar = msg->npar; |
| 171 | int *pars = msg->pars; |
| 172 | int len = msg->len; |
| 173 | const char *datp = msg->datap; |
| 174 | |
| 175 | DBS(nsmc,2002)nsmlib_checkpoint(0,2002); |
| 176 | nsmlib_log("%s%s%s<=%s", |
| 177 | xt(), nsmc->hookptr ? (const char *)nsmc->hookptr : "", |
| 178 | nsmlib_reqname(nsmc, msg->req), |
| 179 | nsmlib_nodename(nsmc, msg->node)); |
| 180 | |
| 181 | DBS(nsmc,2004)nsmlib_checkpoint(0,2004); |
| 182 | for (i = 0; i < 3 && i < npar; i++) { |
| 183 | nsmlib_log("%s%d%s", i==0 ? " (" : "", pars[i], |
| 184 | i==npar-1 ? ")" : (i == 2 ? "...)" : ",") ); |
| 185 | } |
| 186 | DBS(nsmc,2006)nsmlib_checkpoint(0,2006); |
| 187 | for (i = 0; datp && i < 80 && i < len && isprint(datp[i])((*__ctype_b_loc ())[(int) ((datp[i]))] & (unsigned short int) _ISprint); i++) { |
| 188 | nsmlib_log("%s%c%s", i==0 ? " " : "", datp[i], i==79 ? "..." : ""); |
| 189 | } |
| 190 | DBS(nsmc,2008)nsmlib_checkpoint(0,2008); |
| 191 | if (i < 79 && datp && datp[i] == 0 && len > i+1 && isprint(datp[i+1])((*__ctype_b_loc ())[(int) ((datp[i+1]))] & (unsigned short int) _ISprint)) { |
| 192 | nsmlib_log(" "); |
| 193 | } |
| 194 | DBS(nsmc,2010)nsmlib_checkpoint(0,2010); |
| 195 | for (i++; datp && i < 80 && i < len && isprint(datp[i])((*__ctype_b_loc ())[(int) ((datp[i]))] & (unsigned short int) _ISprint); i++) { |
| 196 | nsmlib_log("%c%s", datp[i], i==79 ? "..." : ""); |
| 197 | } |
| 198 | DBS(nsmc,2012)nsmlib_checkpoint(0,2012); |
| 199 | nsmlib_log("\n"); |
| 200 | DBS(nsmc,2014)nsmlib_checkpoint(0,2014); |
| 201 | |
| 202 | if (nsmlib_currecursive <= 1) nsmlib_logflush(); |
| 203 | |
| 204 | DBS(nsmc,2016)nsmlib_checkpoint(0,2016); |
| 205 | } |
| 206 | return 0; |
| 207 | } |
| 208 | /* -- b2nsm_checkpoint -------------------------------------------------- */ |
| 209 | void |
| 210 | b2nsm_checkpoint(NSMcontext *nsmc, int val) |
| 211 | { |
| 212 | nsmlib_checkpoint(nsmc, val); |
| 213 | } |
| 214 | /* -- b2nsm_debuglevel -------------------------------------------------- */ |
| 215 | int |
| 216 | b2nsm_debuglevel(int val) |
| 217 | { |
| 218 | int prev = b2nsm_debugflag & 0xffff; |
| 219 | b2nsm_debugflag = val & 0xffff; |
| 220 | return prev | (nsmlib_debuglevel(val >> 16) << 16); |
| 221 | } |
| 222 | /* -- b2nsm_logging ----------------------------------------------------- */ |
| 223 | FILE * |
| 224 | b2nsm_logging(FILE *fp) |
| 225 | { |
| 226 | logfp = fp; |
| 227 | fp = nsmlib_logging(fp); |
| 228 | if (nsm) { |
| 229 | nsm->hook = b2nsm_loghook; |
| 230 | nsm->hookptr = 0; |
| 231 | } |
| 232 | return fp; |
| 233 | } |
| 234 | /* -- b2nsm_logging2 ---------------------------------------------------- */ |
| 235 | FILE * |
| 236 | b2nsm_logging2(FILE *fp, const char *prefix) |
| 237 | { |
| 238 | logfp = fp; |
| 239 | fp = nsmlib_logging(fp); |
| 240 | if (nsm) { |
| 241 | nsm->hook = b2nsm_loghook; |
| 242 | nsm->hookptr = (const void *)prefix; |
| 243 | } |
| 244 | return fp; |
| 245 | } |
| 246 | /* -- b2nsm_context ----------------------------------------------------- */ |
| 247 | NSMcontext * |
| 248 | b2nsm_context(NSMcontext *context) |
| 249 | { |
| 250 | NSMcontext *prev = nsm; |
| 251 | nsm = context; |
| 252 | return prev; |
| 253 | } |
| 254 | /* -- b2nsm_strerror ---------------------------------------------------- */ |
| 255 | const char * |
| 256 | b2nsm_strerror() |
| 257 | { |
| 258 | switch (b2nsm_errc) { |
| 259 | case NSMEALLOC(-101): |
| 260 | return "cannot alloc"; |
| 261 | default: |
| 262 | return nsmlib_strerror(nsm); |
| 263 | } |
| 264 | } |
| 265 | /* -- b2nsm_callback ---------------------------------------------------- */ |
| 266 | int |
| 267 | b2nsm_callback(const char *name, NSMcallback_t callback) |
| 268 | { |
| 269 | char name_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 270 | int ret; |
| 271 | int oldsig; |
| 272 | |
| 273 | if (! nsm) { |
| 274 | if (logfp) { |
| 275 | nsmlib_log("NSM is not initialized\n"); |
| 276 | nsmlib_logflush(); |
| 277 | } |
| 278 | return -1; |
| 279 | } |
| 280 | |
| 281 | xuprcpy(name_uprcase, name, NSMSYS_NAME_SIZ31+1); |
| 282 | if (nsmlib_register_request(nsm, name_uprcase) < 0) return -1; |
| 283 | |
| 284 | ret = nsmlib_callback(nsm, name_uprcase, callback, NSMLIB_FNSTD); |
| 285 | |
| 286 | if (! logfp) return ret; |
| 287 | |
| 288 | if (ret < 0) { |
| 289 | nsmlib_log("%scallback(%s) registration failed: %s\n", |
| 290 | xt(), name, b2nsm_strerror()); |
| 291 | } else { |
| 292 | if (DBGFLG(1)(b2nsm_debugflag&(1<<(1)))) { |
| 293 | nsmlib_log("%scallback(%s) registered\n", xt(), name_uprcase); |
| 294 | } |
| 295 | } |
| 296 | nsmlib_logflush(); |
| 297 | |
| 298 | return ret; |
| 299 | } |
| 300 | /* -- b2nsm_sendany ----------------------------------------------------- */ |
| 301 | int |
| 302 | b2nsm_sendany(const char *node, const char *req, int npar, int32_t *pars, |
| 303 | int len, const char *datp, const char *caller) |
| 304 | { |
| 305 | int ret; |
| 306 | char node_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 307 | char req_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 308 | int oldsig; |
| 309 | |
| 310 | if (! nsm) return -1; |
| 311 | xuprcpy(node_uprcase, node, NSMSYS_NAME_SIZ31+1); |
| 312 | xuprcpy(req_uprcase, req, NSMSYS_NAME_SIZ31+1); |
| 313 | ret = nsmlib_sendreq(nsm, node_uprcase, req_uprcase, npar, pars, len, datp); |
| 314 | |
| 315 | if (! logfp) return ret; |
| 316 | |
| 317 | if (ret < 0) { |
| 318 | nsmlib_log("%s%s=>%s %s failed: %s\n", |
| 319 | xt(), req, node, caller, b2nsm_strerror()); |
| 320 | } else { |
| 321 | int i; |
| 322 | nsmlib_log("%s%s=>%s", xt(), req, node); |
| 323 | for (i = 0; i<3 && i<npar; i++) { |
| 324 | nsmlib_log("%s%d%s", i==0 ? " (" : "", pars[i], |
| 325 | i==npar-1 ? ")" : (i == 2 ? "...)" : ",") ); |
| 326 | } |
| 327 | for (i = 0; datp && i < 80 && i < len && isprint(datp[i])((*__ctype_b_loc ())[(int) ((datp[i]))] & (unsigned short int) _ISprint); i++) { |
| 328 | nsmlib_log("%s%c%s", i==0 ? " " : "", datp[i], i==79 ? "..." : ""); |
| 329 | } |
| 330 | if (i < 79 && datp && datp[i] == 0 && len > i+1 && isprint(datp[i+1])((*__ctype_b_loc ())[(int) ((datp[i+1]))] & (unsigned short int) _ISprint)) { |
| 331 | nsmlib_log(" "); |
| 332 | } |
| 333 | for (i++; datp && i < 80 && i < len && isprint(datp[i])((*__ctype_b_loc ())[(int) ((datp[i]))] & (unsigned short int) _ISprint); i++) { |
| 334 | nsmlib_log("%c%s", datp[i], i==79 ? "..." : ""); |
| 335 | } |
| 336 | nsmlib_log("\n"); |
| 337 | } |
| 338 | |
| 339 | if (nsmlib_currecursive <= 1) nsmlib_logflush(); |
| 340 | |
| 341 | return ret; |
| 342 | } |
| 343 | /* -- b2nsm_sendreq ----------------------------------------------------- */ |
| 344 | int |
| 345 | b2nsm_sendreq(const char *node, const char *req, int npar, int32_t *pars) |
| 346 | { |
| 347 | return b2nsm_sendany(node, req, npar, pars, 0, 0, "sendreq"); |
| 348 | } |
| 349 | /* -- b2nsm_ok ---------------------------------------------------------- *\ |
| 350 | newstate may be 0 to keep the same state |
| 351 | \* ---------------------------------------------------------------------- */ |
| 352 | int |
| 353 | b2nsm_ok(NSMmsg *msg, const char *newstate, const char *fmt, ...) |
| 354 | { |
| 355 | va_list ap; |
| 356 | const char *node = nsmlib_nodename(nsm, msg->node); |
| 357 | char buf[32+256]; |
| 358 | char *str = 0; |
| 359 | int len; |
| 360 | int pars[2]; |
| 361 | |
| 362 | if (! nsm || ! msg) return -1; |
| 363 | |
| 364 | if (newstate) { |
| 365 | if ((len = strlen(newstate) + 1) > 32) return -1; |
| 366 | strcpy(buf, newstate); |
| 367 | strcpy(((b2nsm_t *)nsm->wrapptr)->state, newstate); |
| 368 | } else { |
| 369 | strcpy(buf, ((b2nsm_t *)nsm->wrapptr)->state); |
| 370 | len = strlen(buf) + 1; |
| 371 | } |
| 372 | |
| 373 | if (fmt) { |
| 374 | va_start(ap, fmt)__builtin_va_start(ap, fmt); |
| 375 | vsnprintf(buf + len, 256, fmt, ap); |
| 376 | va_end(ap)__builtin_va_end(ap); |
| 377 | str = buf + len; |
Value stored to 'str' is never read | |
| 378 | len += strlen(buf + len) + 1; |
| 379 | } |
| 380 | |
| 381 | pars[0] = msg->req; |
| 382 | pars[1] = msg->seq; |
| 383 | |
| 384 | return b2nsm_sendany(node, "OK", 2, pars, len, buf, "ok"); |
| 385 | } |
| 386 | /* -- b2nsm_error ------------------------------------------------------- */ |
| 387 | int |
| 388 | b2nsm_error(NSMmsg *msg, const char *fmt, ...) |
| 389 | { |
| 390 | va_list ap; |
| 391 | const char *node = nsmlib_nodename(nsm, msg->node); |
| 392 | char buf[256]; |
| 393 | char *ptr = buf; |
| 394 | int len; |
| 395 | int pars[2]; |
| 396 | |
| 397 | if (! nsm) return -1; |
| 398 | if (! msg || ! fmt) return -1; |
| 399 | |
| 400 | if (fmt) { |
| 401 | va_start(ap, fmt)__builtin_va_start(ap, fmt); |
| 402 | vsnprintf(buf, 256, fmt, ap); |
| 403 | va_end(ap)__builtin_va_end(ap); |
| 404 | len = strlen(buf) + 1; |
| 405 | } else { |
| 406 | ptr = 0; |
| 407 | len = 0; |
| 408 | } |
| 409 | |
| 410 | pars[0] = msg->req; |
| 411 | pars[1] = msg->seq; |
| 412 | |
| 413 | return b2nsm_sendany(node, "ERROR", 2, pars, len, ptr, "error"); |
| 414 | } |
| 415 | /* -- b2nsm_readmem ----------------------------------------------------- */ |
| 416 | int |
| 417 | b2nsm_readmem(void *buf, const char *dat, const char *fmt, int rev) |
| 418 | { |
| 419 | char dat_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 420 | int ret; |
| 421 | if (! nsm) return 0; |
| 422 | xuprcpy(dat_uprcase, dat, NSMSYS_NAME_SIZ31+1); |
| 423 | ret = nsmlib_readmem(nsm, buf, dat_uprcase, fmt, rev); |
| 424 | |
| 425 | if (! logfp) return ret; |
| 426 | if (ret < 0) { |
| 427 | nsmlib_log("%sreadmem(%s,rev.%d) failed: %s\n", |
| 428 | xt(), dat, rev, b2nsm_strerror()); |
| 429 | } |
| 430 | return ret; |
| 431 | } |
| 432 | /* -- b2nsm_statmem ----------------------------------------------------- */ |
| 433 | int |
| 434 | b2nsm_statmem(const char *dat, char *fmtbuf, int buflen) |
| 435 | { |
| 436 | char dat_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 437 | int ret; |
| 438 | if (! nsm) return 0; |
| 439 | xuprcpy(dat_uprcase, dat, NSMSYS_NAME_SIZ31+1); |
| 440 | ret = nsmlib_statmem(nsm, dat_uprcase, fmtbuf, buflen); |
| 441 | |
| 442 | if (! logfp) return ret; |
| 443 | |
| 444 | if (ret < 0) { |
| 445 | nsmlib_log("%sstatmem(%s) failed: %s\n", |
| 446 | xt(), dat, b2nsm_strerror()); |
| 447 | } else if (ret == 0) { |
| 448 | nsmlib_log("%sstatmem(%s) no fmt\n", xt(), dat); |
| 449 | } else { |
| 450 | nsmlib_log("%sstatmem(%s) fmt %s\n", xt(), dat, fmtbuf); |
| 451 | } |
| 452 | return ret; |
| 453 | } |
| 454 | /* -- b2nsm_openmem ----------------------------------------------------- */ |
| 455 | void * |
| 456 | b2nsm_openmem(const char *dat, const char *fmt, int rev) |
| 457 | { |
| 458 | char dat_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 459 | void *ptr; |
| 460 | if (! nsm) return 0; |
| 461 | xuprcpy(dat_uprcase, dat, NSMSYS_NAME_SIZ31+1); |
| 462 | ptr = nsmlib_openmem(nsm, dat_uprcase, fmt, rev); |
| 463 | |
| 464 | if (! logfp) return ptr; |
| 465 | |
| 466 | if (! ptr) { |
| 467 | nsmlib_log("%sopenmem(%s,rev.%d) failed: %s\n", |
| 468 | xt(), dat, rev, b2nsm_strerror()); |
| 469 | } else { |
| 470 | nsmlib_log("%sopenmem(%s,rev.%d) at %p\n", xt(), dat, rev, ptr); |
| 471 | } |
| 472 | return ptr; |
| 473 | } |
| 474 | /* -- b2nsm_allocmem ---------------------------------------------------- */ |
| 475 | void * |
| 476 | b2nsm_allocmem(const char *dat, const char *fmt, int rev, float cycle) |
| 477 | { |
| 478 | char dat_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 479 | void *ptr; |
| 480 | if (! nsm) return 0; |
| 481 | xuprcpy(dat_uprcase, dat, NSMSYS_NAME_SIZ31+1); |
| 482 | ptr = nsmlib_allocmem(nsm, dat_uprcase, fmt, rev, cycle); |
| 483 | |
| 484 | if (! logfp) return ptr; |
| 485 | |
| 486 | if (! ptr) { |
| 487 | nsmlib_log("%sallocmem(%s,rev.%d) failed: %s\n", |
| 488 | xt(), dat, rev, b2nsm_strerror()); |
| 489 | } else { |
| 490 | nsmlib_log("%sallocmem(%s,rev.%d) at %p\n", xt(), dat, rev, ptr); |
| 491 | } |
| 492 | return ptr; |
| 493 | } |
| 494 | /* -- b2nsm_flushmem ---------------------------------------------------- */ |
| 495 | int |
| 496 | b2nsm_flushmem(const void *ptr, int siz) |
| 497 | { |
| 498 | int ret; |
| 499 | if (! nsm) return 0; |
| 500 | ret = nsmlib_flushmem(nsm, ptr, siz); |
| 501 | |
| 502 | if (logfp && ret < 0) { |
| 503 | nsmlib_log("%sflushmem(%x,%d) failed (ret=%d): %s\n", |
| 504 | xt(), ptr, siz, ret, b2nsm_strerror()); |
| 505 | } |
| 506 | return ret; |
| 507 | } |
| 508 | /* -- b2nsm_wait -------------------------------------------------------- */ |
| 509 | int |
| 510 | b2nsm_wait(float timeout) |
| 511 | { |
| 512 | /* int wait_msec = (int)(timeout * 1000); */ |
| 513 | int wait_usec = (int)(timeout * 1000); |
| 514 | char buf[NSM_TCPMSGSIZ(16 + (256*4 + 65536))]; /* should not be static */ |
| 515 | NSMcontext *nsmc = nsmlib_selectc(0, wait_usec); /* usesig = 0 */ |
| 516 | NSMcontext *nsmsav; |
| 517 | |
| 518 | if (! nsmc) return 0; |
| 519 | |
| 520 | /* receive (wait 1 sec) */ |
| 521 | if (nsmlib_recv(nsmc, (struct NSMtcphead_struct *)buf, 1000) <= 0) { |
| 522 | return -1; |
| 523 | } |
| 524 | |
| 525 | /* callback function */ |
| 526 | nsmsav = nsm; |
| 527 | nsm = nsmc; |
| 528 | nsmlib_call(nsmc, (struct NSMtcphead_struct *)buf); |
| 529 | nsm = nsmsav; |
| 530 | return 1; |
| 531 | } |
| 532 | /* -- b2nsm_init2 ------------------------------------------------------- */ |
| 533 | /* node is anonymous when nodename = 0 */ |
| 534 | /* ---------------------------------------------------------------------- */ |
| 535 | NSMcontext * |
| 536 | b2nsm_init2(const char *nodename, int usesig, |
| 537 | const char *hostname, int port, int shmkey) |
| 538 | { |
| 539 | char nodename_uprcase[NSMSYS_NAME_SIZ31+1]; |
| 540 | b2nsm_errc = 0; |
| 541 | if (nodename) { |
| 542 | xuprcpy(nodename_uprcase, nodename, NSMSYS_NAME_SIZ31+1); |
| 543 | nsm = nsmlib_init(nodename_uprcase, hostname, port, shmkey); |
| 544 | } else { |
| 545 | nsm = nsmlib_init(nodename, hostname, port, shmkey); |
| 546 | } |
| 547 | if (nsm == 0) return 0; |
| 548 | nsmlib_usesig(nsm, usesig); |
| 549 | if (logfp) nsm->hook = b2nsm_loghook; |
| 550 | nsm->wrapptr = (void *)malloc(sizeof(b2nsm_t)); |
| 551 | if (! nsm->wrapptr) { |
| 552 | free(nsm); |
| 553 | nsm = 0; |
| 554 | b2nsm_errc = NSMEALLOC(-101); |
| 555 | } |
| 556 | memset((char *)nsm->wrapptr, 0, sizeof(b2nsm_t)); |
| 557 | strcpy(((b2nsm_t *)nsm->wrapptr)->state, "UNKNOWN"); |
| 558 | |
| 559 | return nsm; |
| 560 | } |
| 561 | /* -- b2nsm_init -------------------------------------------------------- */ |
| 562 | NSMcontext * |
| 563 | b2nsm_init(const char *nodename) |
| 564 | { |
| 565 | return b2nsm_init2(nodename, 1, 0, 0, 0); |
| 566 | } |
| 567 | /* -- b2nsm_term -------------------------------------------------------- */ |
| 568 | int |
| 569 | b2nsm_term(const char *nodename) |
| 570 | { |
| 571 | return nsmlib_term(nsm); |
| 572 | } |
| 573 | /* -- (emacs outline mode setup) ------------------------------------- */ |
| 574 | /* |
| 575 | // Local Variables: *** |
| 576 | // mode:outline-minor *** |
| 577 | // outline-regexp:"^/\\* --[+ ]" *** |
| 578 | // End: *** |
| 579 | */ |