00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <netlink-local.h>
00019 #include <netlink/netlink.h>
00020 #include <netlink/utils.h>
00021 #include <linux/socket.h>
00022
00023
00024
00025
00026 int nl_debug = 0;
00027
00028 struct nl_dump_params nl_debug_dp = {
00029 .dp_type = NL_DUMP_DETAILS,
00030 };
00031
00032 static void __init nl_debug_init(void)
00033 {
00034 char *nldbg, *end;
00035
00036 if ((nldbg = getenv("NLDBG"))) {
00037 long level = strtol(nldbg, &end, 0);
00038 if (nldbg != end)
00039 nl_debug = level;
00040 }
00041
00042 nl_debug_dp.dp_fd = stderr;
00043 }
00044
00045 int __nl_read_num_str_file(const char *path, int (*cb)(long, const char *))
00046 {
00047 FILE *fd;
00048 char buf[128];
00049
00050 fd = fopen(path, "r");
00051 if (fd == NULL)
00052 return -nl_syserr2nlerr(errno);
00053
00054 while (fgets(buf, sizeof(buf), fd)) {
00055 int goodlen, err;
00056 long num;
00057 char *end;
00058
00059 if (*buf == '#' || *buf == '\n' || *buf == '\r')
00060 continue;
00061
00062 num = strtol(buf, &end, 0);
00063 if (end == buf)
00064 return -NLE_INVAL;
00065
00066 if (num == LONG_MIN || num == LONG_MAX)
00067 return -NLE_RANGE;
00068
00069 while (*end == ' ' || *end == '\t')
00070 end++;
00071
00072 goodlen = strcspn(end, "#\r\n\t ");
00073 if (goodlen == 0)
00074 return -NLE_INVAL;
00075
00076 end[goodlen] = '\0';
00077
00078 err = cb(num, end);
00079 if (err < 0)
00080 return err;
00081 }
00082
00083 fclose(fd);
00084
00085 return 0;
00086 }
00087
00088
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103 double nl_cancel_down_bytes(unsigned long long l, char **unit)
00104 {
00105 if (l >= 1099511627776LL) {
00106 *unit = "TiB";
00107 return ((double) l) / 1099511627776LL;
00108 } else if (l >= 1073741824) {
00109 *unit = "GiB";
00110 return ((double) l) / 1073741824;
00111 } else if (l >= 1048576) {
00112 *unit = "MiB";
00113 return ((double) l) / 1048576;
00114 } else if (l >= 1024) {
00115 *unit = "KiB";
00116 return ((double) l) / 1024;
00117 } else {
00118 *unit = "B";
00119 return (double) l;
00120 }
00121 }
00122
00123
00124
00125
00126
00127
00128
00129
00130
00131
00132
00133 double nl_cancel_down_bits(unsigned long long l, char **unit)
00134 {
00135 if (l >= 1099511627776ULL) {
00136 *unit = "Tbit";
00137 return ((double) l) / 1099511627776ULL;
00138 } else if (l >= 1073741824) {
00139 *unit = "Gbit";
00140 return ((double) l) / 1073741824;
00141 } else if (l >= 1048576) {
00142 *unit = "Mbit";
00143 return ((double) l) / 1048576;
00144 } else if (l >= 1024) {
00145 *unit = "Kbit";
00146 return ((double) l) / 1024;
00147 } else {
00148 *unit = "bit";
00149 return (double) l;
00150 }
00151
00152 }
00153
00154
00155
00156
00157
00158
00159
00160
00161
00162
00163
00164 double nl_cancel_down_us(uint32_t l, char **unit)
00165 {
00166 if (l >= 1000000) {
00167 *unit = "s";
00168 return ((double) l) / 1000000;
00169 } else if (l >= 1000) {
00170 *unit = "ms";
00171 return ((double) l) / 1000;
00172 } else {
00173 *unit = "us";
00174 return (double) l;
00175 }
00176 }
00177
00178
00179
00180
00181
00182
00183
00184
00185
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195
00196
00197
00198 long nl_size2int(const char *str)
00199 {
00200 char *p;
00201 long l = strtol(str, &p, 0);
00202 if (p == str)
00203 return -NLE_INVAL;
00204
00205 if (*p) {
00206 if (!strcasecmp(p, "kb") || !strcasecmp(p, "k"))
00207 l *= 1024;
00208 else if (!strcasecmp(p, "gb") || !strcasecmp(p, "g"))
00209 l *= 1024*1024*1024;
00210 else if (!strcasecmp(p, "gbit"))
00211 l *= 1024*1024*1024/8;
00212 else if (!strcasecmp(p, "mb") || !strcasecmp(p, "m"))
00213 l *= 1024*1024;
00214 else if (!strcasecmp(p, "mbit"))
00215 l *= 1024*1024/8;
00216 else if (!strcasecmp(p, "kbit"))
00217 l *= 1024/8;
00218 else if (!strcasecmp(p, "bit"))
00219 l /= 8;
00220 else if (strcasecmp(p, "b") != 0)
00221 return -NLE_INVAL;
00222 }
00223
00224 return l;
00225 }
00226
00227
00228
00229
00230
00231
00232
00233
00234
00235
00236
00237
00238
00239
00240 long nl_prob2int(const char *str)
00241 {
00242 char *p;
00243 double d = strtod(str, &p);
00244
00245 if (p == str)
00246 return -NLE_INVAL;
00247
00248 if (d > 1.0)
00249 d /= 100.0f;
00250
00251 if (d > 1.0f || d < 0.0f)
00252 return -NLE_RANGE;
00253
00254 if (*p && strcmp(p, "%") != 0)
00255 return -NLE_INVAL;
00256
00257 return rint(d * NL_PROB_MAX);
00258 }
00259
00260
00261
00262
00263
00264
00265
00266
00267 #ifdef USER_HZ
00268 static uint32_t user_hz = USER_HZ;
00269 #else
00270 static uint32_t user_hz = 100;
00271 #endif
00272
00273 static double ticks_per_usec = 1.0f;
00274
00275
00276
00277
00278
00279
00280
00281
00282
00283
00284 static void __init get_psched_settings(void)
00285 {
00286 char name[FILENAME_MAX];
00287 FILE *fd;
00288 int got_hz = 0, got_tick = 0;
00289
00290 if (getenv("HZ")) {
00291 long hz = strtol(getenv("HZ"), NULL, 0);
00292
00293 if (LONG_MIN != hz && LONG_MAX != hz) {
00294 user_hz = hz;
00295 got_hz = 1;
00296 }
00297 }
00298
00299 if (!got_hz)
00300 user_hz = sysconf(_SC_CLK_TCK);
00301
00302 if (getenv("TICKS_PER_USEC")) {
00303 double t = strtod(getenv("TICKS_PER_USEC"), NULL);
00304
00305 ticks_per_usec = t;
00306 got_tick = 1;
00307 }
00308
00309
00310 if (getenv("PROC_NET_PSCHED"))
00311 snprintf(name, sizeof(name), "%s", getenv("PROC_NET_PSCHED"));
00312 else if (getenv("PROC_ROOT"))
00313 snprintf(name, sizeof(name), "%s/net/psched",
00314 getenv("PROC_ROOT"));
00315 else
00316 strncpy(name, "/proc/net/psched", sizeof(name) - 1);
00317
00318 if ((fd = fopen(name, "r"))) {
00319 uint32_t tick, us, nom;
00320 int r = fscanf(fd, "%08x%08x%08x%*08x", &tick, &us, &nom);
00321
00322 if (4 == r && nom == 1000000 && !got_tick)
00323 ticks_per_usec = (double)tick/(double)us;
00324
00325 fclose(fd);
00326 }
00327 }
00328
00329
00330
00331
00332
00333 int nl_get_hz(void)
00334 {
00335 return user_hz;
00336 }
00337
00338
00339
00340
00341
00342
00343
00344 uint32_t nl_us2ticks(uint32_t us)
00345 {
00346 return us * ticks_per_usec;
00347 }
00348
00349
00350
00351
00352
00353
00354
00355 uint32_t nl_ticks2us(uint32_t ticks)
00356 {
00357 return ticks / ticks_per_usec;
00358 }
00359
00360 int nl_str2msec(const char *str, uint64_t *result)
00361 {
00362 uint64_t total = 0, l;
00363 int plen;
00364 char *p;
00365
00366 do {
00367 l = strtoul(str, &p, 0);
00368 if (p == str)
00369 return -NLE_INVAL;
00370 else if (*p) {
00371 plen = strcspn(p, " \t");
00372
00373 if (!plen)
00374 total += l;
00375 else if (!strncasecmp(p, "sec", plen))
00376 total += (l * 1000);
00377 else if (!strncasecmp(p, "min", plen))
00378 total += (l * 1000*60);
00379 else if (!strncasecmp(p, "hour", plen))
00380 total += (l * 1000*60*60);
00381 else if (!strncasecmp(p, "day", plen))
00382 total += (l * 1000*60*60*24);
00383 else
00384 return -NLE_INVAL;
00385
00386 str = p + plen;
00387 } else
00388 total += l;
00389 } while (*str && *p);
00390
00391 *result = total;
00392
00393 return 0;
00394 }
00395
00396
00397
00398
00399
00400
00401
00402
00403
00404
00405
00406
00407
00408 char * nl_msec2str(uint64_t msec, char *buf, size_t len)
00409 {
00410 int i, split[5];
00411 char *units[] = {"d", "h", "m", "s", "msec"};
00412
00413 #define _SPLIT(idx, unit) if ((split[idx] = msec / unit) > 0) msec %= unit
00414 _SPLIT(0, 86400000);
00415 _SPLIT(1, 3600000);
00416 _SPLIT(2, 60000);
00417 _SPLIT(3, 1000);
00418 #undef _SPLIT
00419 split[4] = msec;
00420
00421 memset(buf, 0, len);
00422
00423 for (i = 0; i < ARRAY_SIZE(split); i++) {
00424 if (split[i] > 0) {
00425 char t[64];
00426 snprintf(t, sizeof(t), "%s%d%s",
00427 strlen(buf) ? " " : "", split[i], units[i]);
00428 strncat(buf, t, len - strlen(buf) - 1);
00429 }
00430 }
00431
00432 return buf;
00433 }
00434
00435
00436
00437
00438
00439
00440
00441
00442 static struct trans_tbl nlfamilies[] = {
00443 __ADD(NETLINK_ROUTE,route)
00444 __ADD(NETLINK_USERSOCK,usersock)
00445 __ADD(NETLINK_FIREWALL,firewall)
00446 __ADD(NETLINK_INET_DIAG,inetdiag)
00447 __ADD(NETLINK_NFLOG,nflog)
00448 __ADD(NETLINK_XFRM,xfrm)
00449 __ADD(NETLINK_SELINUX,selinux)
00450 __ADD(NETLINK_ISCSI,iscsi)
00451 __ADD(NETLINK_AUDIT,audit)
00452 __ADD(NETLINK_FIB_LOOKUP,fib_lookup)
00453 __ADD(NETLINK_CONNECTOR,connector)
00454 __ADD(NETLINK_NETFILTER,netfilter)
00455 __ADD(NETLINK_IP6_FW,ip6_fw)
00456 __ADD(NETLINK_DNRTMSG,dnrtmsg)
00457 __ADD(NETLINK_KOBJECT_UEVENT,kobject_uevent)
00458 __ADD(NETLINK_GENERIC,generic)
00459 __ADD(NETLINK_SCSITRANSPORT,scsitransport)
00460 __ADD(NETLINK_ECRYPTFS,ecryptfs)
00461 };
00462
00463 char * nl_nlfamily2str(int family, char *buf, size_t size)
00464 {
00465 return __type2str(family, buf, size, nlfamilies,
00466 ARRAY_SIZE(nlfamilies));
00467 }
00468
00469 int nl_str2nlfamily(const char *name)
00470 {
00471 return __str2type(name, nlfamilies, ARRAY_SIZE(nlfamilies));
00472 }
00473
00474
00475
00476
00477
00478
00479
00480
00481
00482
00483 static struct trans_tbl llprotos[] = {
00484 {0, "generic"},
00485 __ADD(ARPHRD_ETHER,ether)
00486 __ADD(ARPHRD_EETHER,eether)
00487 __ADD(ARPHRD_AX25,ax25)
00488 __ADD(ARPHRD_PRONET,pronet)
00489 __ADD(ARPHRD_CHAOS,chaos)
00490 __ADD(ARPHRD_IEEE802,ieee802)
00491 __ADD(ARPHRD_ARCNET,arcnet)
00492 __ADD(ARPHRD_APPLETLK,atalk)
00493 __ADD(ARPHRD_DLCI,dlci)
00494 __ADD(ARPHRD_ATM,atm)
00495 __ADD(ARPHRD_METRICOM,metricom)
00496 __ADD(ARPHRD_IEEE1394,ieee1394)
00497 #ifdef ARPHRD_EUI64
00498 __ADD(ARPHRD_EUI64,eui64)
00499 #endif
00500 __ADD(ARPHRD_INFINIBAND,infiniband)
00501 __ADD(ARPHRD_SLIP,slip)
00502 __ADD(ARPHRD_CSLIP,cslip)
00503 __ADD(ARPHRD_SLIP6,slip6)
00504 __ADD(ARPHRD_CSLIP6,cslip6)
00505 __ADD(ARPHRD_RSRVD,rsrvd)
00506 __ADD(ARPHRD_ADAPT,adapt)
00507 __ADD(ARPHRD_ROSE,rose)
00508 __ADD(ARPHRD_X25,x25)
00509 #ifdef ARPHRD_HWX25
00510 __ADD(ARPHRD_HWX25,hwx25)
00511 #endif
00512 __ADD(ARPHRD_PPP,ppp)
00513 __ADD(ARPHRD_HDLC,hdlc)
00514 __ADD(ARPHRD_LAPB,lapb)
00515 __ADD(ARPHRD_DDCMP,ddcmp)
00516 __ADD(ARPHRD_RAWHDLC,rawhdlc)
00517 __ADD(ARPHRD_TUNNEL,ipip)
00518 __ADD(ARPHRD_TUNNEL6,tunnel6)
00519 __ADD(ARPHRD_FRAD,frad)
00520 __ADD(ARPHRD_SKIP,skip)
00521 __ADD(ARPHRD_LOOPBACK,loopback)
00522 __ADD(ARPHRD_LOCALTLK,localtlk)
00523 __ADD(ARPHRD_FDDI,fddi)
00524 __ADD(ARPHRD_BIF,bif)
00525 __ADD(ARPHRD_SIT,sit)
00526 __ADD(ARPHRD_IPDDP,ip/ddp)
00527 __ADD(ARPHRD_IPGRE,gre)
00528 __ADD(ARPHRD_PIMREG,pimreg)
00529 __ADD(ARPHRD_HIPPI,hippi)
00530 __ADD(ARPHRD_ASH,ash)
00531 __ADD(ARPHRD_ECONET,econet)
00532 __ADD(ARPHRD_IRDA,irda)
00533 __ADD(ARPHRD_FCPP,fcpp)
00534 __ADD(ARPHRD_FCAL,fcal)
00535 __ADD(ARPHRD_FCPL,fcpl)
00536 __ADD(ARPHRD_FCFABRIC,fcfb_0)
00537 __ADD(ARPHRD_FCFABRIC+1,fcfb_1)
00538 __ADD(ARPHRD_FCFABRIC+2,fcfb_2)
00539 __ADD(ARPHRD_FCFABRIC+3,fcfb_3)
00540 __ADD(ARPHRD_FCFABRIC+4,fcfb_4)
00541 __ADD(ARPHRD_FCFABRIC+5,fcfb_5)
00542 __ADD(ARPHRD_FCFABRIC+6,fcfb_6)
00543 __ADD(ARPHRD_FCFABRIC+7,fcfb_7)
00544 __ADD(ARPHRD_FCFABRIC+8,fcfb_8)
00545 __ADD(ARPHRD_FCFABRIC+9,fcfb_9)
00546 __ADD(ARPHRD_FCFABRIC+10,fcfb_10)
00547 __ADD(ARPHRD_FCFABRIC+11,fcfb_11)
00548 __ADD(ARPHRD_FCFABRIC+12,fcfb_12)
00549 __ADD(ARPHRD_IEEE802_TR,tr)
00550 __ADD(ARPHRD_IEEE80211,ieee802.11)
00551 #ifdef ARPHRD_IEEE80211_PRISM
00552 __ADD(ARPHRD_IEEE80211_PRISM, ieee802.11_prism)
00553 #endif
00554 #ifdef ARPHRD_VOID
00555 __ADD(ARPHRD_VOID,void)
00556 #endif
00557 };
00558
00559 char * nl_llproto2str(int llproto, char *buf, size_t len)
00560 {
00561 return __type2str(llproto, buf, len, llprotos, ARRAY_SIZE(llprotos));
00562 }
00563
00564 int nl_str2llproto(const char *name)
00565 {
00566 return __str2type(name, llprotos, ARRAY_SIZE(llprotos));
00567 }
00568
00569
00570
00571
00572
00573
00574
00575
00576
00577 static struct trans_tbl ether_protos[] = {
00578 __ADD(ETH_P_LOOP,loop)
00579 __ADD(ETH_P_PUP,pup)
00580 __ADD(ETH_P_PUPAT,pupat)
00581 __ADD(ETH_P_IP,ip)
00582 __ADD(ETH_P_X25,x25)
00583 __ADD(ETH_P_ARP,arp)
00584 __ADD(ETH_P_BPQ,bpq)
00585 __ADD(ETH_P_IEEEPUP,ieeepup)
00586 __ADD(ETH_P_IEEEPUPAT,ieeepupat)
00587 __ADD(ETH_P_DEC,dec)
00588 __ADD(ETH_P_DNA_DL,dna_dl)
00589 __ADD(ETH_P_DNA_RC,dna_rc)
00590 __ADD(ETH_P_DNA_RT,dna_rt)
00591 __ADD(ETH_P_LAT,lat)
00592 __ADD(ETH_P_DIAG,diag)
00593 __ADD(ETH_P_CUST,cust)
00594 __ADD(ETH_P_SCA,sca)
00595 __ADD(ETH_P_RARP,rarp)
00596 __ADD(ETH_P_ATALK,atalk)
00597 __ADD(ETH_P_AARP,aarp)
00598 #ifdef ETH_P_8021Q
00599 __ADD(ETH_P_8021Q,802.1q)
00600 #endif
00601 __ADD(ETH_P_IPX,ipx)
00602 __ADD(ETH_P_IPV6,ipv6)
00603 #ifdef ETH_P_WCCP
00604 __ADD(ETH_P_WCCP,wccp)
00605 #endif
00606 __ADD(ETH_P_PPP_DISC,ppp_disc)
00607 __ADD(ETH_P_PPP_SES,ppp_ses)
00608 __ADD(ETH_P_MPLS_UC,mpls_uc)
00609 __ADD(ETH_P_MPLS_MC,mpls_mc)
00610 __ADD(ETH_P_ATMMPOA,atmmpoa)
00611 __ADD(ETH_P_ATMFATE,atmfate)
00612 __ADD(ETH_P_EDP2,edp2)
00613 __ADD(ETH_P_802_3,802.3)
00614 __ADD(ETH_P_AX25,ax25)
00615 __ADD(ETH_P_ALL,all)
00616 __ADD(ETH_P_802_2,802.2)
00617 __ADD(ETH_P_SNAP,snap)
00618 __ADD(ETH_P_DDCMP,ddcmp)
00619 __ADD(ETH_P_WAN_PPP,wan_ppp)
00620 __ADD(ETH_P_PPP_MP,ppp_mp)
00621 __ADD(ETH_P_LOCALTALK,localtalk)
00622 __ADD(ETH_P_PPPTALK,ppptalk)
00623 __ADD(ETH_P_TR_802_2,tr_802.2)
00624 __ADD(ETH_P_MOBITEX,mobitex)
00625 __ADD(ETH_P_CONTROL,control)
00626 __ADD(ETH_P_IRDA,irda)
00627 __ADD(ETH_P_ECONET,econet)
00628 __ADD(ETH_P_HDLC,hdlc)
00629 };
00630
00631 char *nl_ether_proto2str(int eproto, char *buf, size_t len)
00632 {
00633 return __type2str(eproto, buf, len, ether_protos,
00634 ARRAY_SIZE(ether_protos));
00635 }
00636
00637 int nl_str2ether_proto(const char *name)
00638 {
00639 return __str2type(name, ether_protos, ARRAY_SIZE(ether_protos));
00640 }
00641
00642
00643
00644
00645
00646
00647
00648
00649 char *nl_ip_proto2str(int proto, char *buf, size_t len)
00650 {
00651 struct protoent *p = getprotobynumber(proto);
00652
00653 if (p) {
00654 snprintf(buf, len, "%s", p->p_name);
00655 return buf;
00656 }
00657
00658 snprintf(buf, len, "0x%x", proto);
00659 return buf;
00660 }
00661
00662 int nl_str2ip_proto(const char *name)
00663 {
00664 struct protoent *p = getprotobyname(name);
00665 unsigned long l;
00666 char *end;
00667
00668 if (p)
00669 return p->p_proto;
00670
00671 l = strtoul(name, &end, 0);
00672 if (l == ULONG_MAX || *end != '\0')
00673 return -NLE_OBJ_NOTFOUND;
00674
00675 return (int) l;
00676 }
00677
00678
00679
00680
00681
00682
00683
00684
00685
00686
00687
00688
00689
00690
00691
00692
00693
00694
00695 void nl_new_line(struct nl_dump_params *params)
00696 {
00697 params->dp_line++;
00698
00699 if (params->dp_prefix) {
00700 int i;
00701 for (i = 0; i < params->dp_prefix; i++) {
00702 if (params->dp_fd)
00703 fprintf(params->dp_fd, " ");
00704 else if (params->dp_buf)
00705 strncat(params->dp_buf, " ",
00706 params->dp_buflen -
00707 sizeof(params->dp_buf) - 1);
00708 }
00709 }
00710
00711 if (params->dp_nl_cb)
00712 params->dp_nl_cb(params, params->dp_line);
00713 }
00714
00715 static void dump_one(struct nl_dump_params *parms, const char *fmt,
00716 va_list args)
00717 {
00718 if (parms->dp_fd)
00719 vfprintf(parms->dp_fd, fmt, args);
00720 else if (parms->dp_buf || parms->dp_cb) {
00721 char *buf = NULL;
00722 vasprintf(&buf, fmt, args);
00723 if (parms->dp_cb)
00724 parms->dp_cb(parms, buf);
00725 else
00726 strncat(parms->dp_buf, buf,
00727 parms->dp_buflen - strlen(parms->dp_buf) - 1);
00728 free(buf);
00729 }
00730 }
00731
00732
00733
00734
00735
00736
00737
00738
00739
00740
00741
00742 void nl_dump(struct nl_dump_params *params, const char *fmt, ...)
00743 {
00744 va_list args;
00745
00746 va_start(args, fmt);
00747 dump_one(params, fmt, args);
00748 va_end(args);
00749 }
00750
00751 void nl_dump_line(struct nl_dump_params *parms, const char *fmt, ...)
00752 {
00753 va_list args;
00754
00755 nl_new_line(parms);
00756
00757 va_start(args, fmt);
00758 dump_one(parms, fmt, args);
00759 va_end(args);
00760 }
00761
00762
00763
00764
00765
00766
00767 int __trans_list_add(int i, const char *a, struct nl_list_head *head)
00768 {
00769 struct trans_list *tl;
00770
00771 tl = calloc(1, sizeof(*tl));
00772 if (!tl)
00773 return -NLE_NOMEM;
00774
00775 tl->i = i;
00776 tl->a = strdup(a);
00777
00778 nl_list_add_tail(&tl->list, head);
00779
00780 return 0;
00781 }
00782
00783 void __trans_list_clear(struct nl_list_head *head)
00784 {
00785 struct trans_list *tl, *next;
00786
00787 nl_list_for_each_entry_safe(tl, next, head, list) {
00788 free(tl->a);
00789 free(tl);
00790 }
00791 }
00792
00793 char *__type2str(int type, char *buf, size_t len, struct trans_tbl *tbl,
00794 size_t tbl_len)
00795 {
00796 int i;
00797 for (i = 0; i < tbl_len; i++) {
00798 if (tbl[i].i == type) {
00799 snprintf(buf, len, "%s", tbl[i].a);
00800 return buf;
00801 }
00802 }
00803
00804 snprintf(buf, len, "0x%x", type);
00805 return buf;
00806 }
00807
00808 char *__list_type2str(int type, char *buf, size_t len,
00809 struct nl_list_head *head)
00810 {
00811 struct trans_list *tl;
00812
00813 nl_list_for_each_entry(tl, head, list) {
00814 if (tl->i == type) {
00815 snprintf(buf, len, "%s", tl->a);
00816 return buf;
00817 }
00818 }
00819
00820 snprintf(buf, len, "0x%x", type);
00821 return buf;
00822 }
00823
00824 char *__flags2str(int flags, char *buf, size_t len,
00825 struct trans_tbl *tbl, size_t tbl_len)
00826 {
00827 int i;
00828 int tmp = flags;
00829
00830 memset(buf, 0, len);
00831
00832 for (i = 0; i < tbl_len; i++) {
00833 if (tbl[i].i & tmp) {
00834 tmp &= ~tbl[i].i;
00835 strncat(buf, tbl[i].a, len - strlen(buf) - 1);
00836 if ((tmp & flags))
00837 strncat(buf, ",", len - strlen(buf) - 1);
00838 }
00839 }
00840
00841 return buf;
00842 }
00843
00844 int __str2type(const char *buf, struct trans_tbl *tbl, size_t tbl_len)
00845 {
00846 unsigned long l;
00847 char *end;
00848 int i;
00849
00850 if (*buf == '\0')
00851 return -NLE_INVAL;
00852
00853 for (i = 0; i < tbl_len; i++)
00854 if (!strcasecmp(tbl[i].a, buf))
00855 return tbl[i].i;
00856
00857 l = strtoul(buf, &end, 0);
00858 if (l == ULONG_MAX || *end != '\0')
00859 return -NLE_OBJ_NOTFOUND;
00860
00861 return (int) l;
00862 }
00863
00864 int __list_str2type(const char *buf, struct nl_list_head *head)
00865 {
00866 struct trans_list *tl;
00867 unsigned long l;
00868 char *end;
00869
00870 if (*buf == '\0')
00871 return -NLE_INVAL;
00872
00873 nl_list_for_each_entry(tl, head, list) {
00874 if (!strcasecmp(tl->a, buf))
00875 return tl->i;
00876 }
00877
00878 l = strtoul(buf, &end, 0);
00879 if (l == ULONG_MAX || *end != '\0')
00880 return -NLE_OBJ_NOTFOUND;
00881
00882 return (int) l;
00883 }
00884
00885 int __str2flags(const char *buf, struct trans_tbl *tbl, size_t tbl_len)
00886 {
00887 int i, flags = 0, len;
00888 char *p = (char *) buf, *t;
00889
00890 for (;;) {
00891 if (*p == ' ')
00892 p++;
00893
00894 t = strchr(p, ',');
00895 len = t ? t - p : strlen(p);
00896 for (i = 0; i < tbl_len; i++)
00897 if (!strncasecmp(tbl[i].a, p, len))
00898 flags |= tbl[i].i;
00899
00900 if (!t)
00901 return flags;
00902
00903 p = ++t;
00904 }
00905
00906 return 0;
00907 }
00908
00909 void dump_from_ops(struct nl_object *obj, struct nl_dump_params *params)
00910 {
00911 int type = params->dp_type;
00912
00913 if (type < 0 || type > NL_DUMP_MAX)
00914 BUG();
00915
00916 params->dp_line = 0;
00917
00918 if (params->dp_dump_msgtype) {
00919 #if 0
00920
00921 char buf[64];
00922
00923 dp_dump_line(params, 0, "%s ",
00924 nl_cache_mngt_type2name(obj->ce_ops,
00925 obj->ce_ops->co_protocol,
00926 obj->ce_msgtype,
00927 buf, sizeof(buf)));
00928 #endif
00929 params->dp_pre_dump = 1;
00930 }
00931
00932 if (obj->ce_ops->oo_dump[type])
00933 obj->ce_ops->oo_dump[type](obj, params);
00934 }
00935
00936
00937
00938