![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to copy.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu|
Return to copy.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ingres / source / dbu |
1.1 ! root 1: # include <stdio.h> ! 2: # include <func.h> ! 3: # include <pv.h> ! 4: # include <ingres.h> ! 5: # include <aux.h> ! 6: # include <access.h> ! 7: # include <symbol.h> ! 8: # include <lock.h> ! 9: # include <signal.h> ! 10: # include <sccs.h> ! 11: # include <errors.h> ! 12: ! 13: SCCSID(@(#)copy.c 8.5 2/8/85) ! 14: ! 15: /* ! 16: ** COPY -- Performs an ingres COPY. ! 17: ** ! 18: ** Trace Flags: ! 19: ** 30 ! 20: */ ! 21: ! 22: ! 23: # define MAXMAP 3 * MAXDOM ! 24: # define DUMMY 'd' ! 25: # define ESCAPE '\\' ! 26: ! 27: extern short tTdbu[100]; ! 28: extern int copy(); ! 29: extern int null_fn(); ! 30: ! 31: struct fn_def CopyFn = ! 32: { ! 33: "COPY", ! 34: copy, ! 35: null_fn, ! 36: null_fn, ! 37: NULL, ! 38: 0, ! 39: tTdbu, ! 40: 100, ! 41: 'Z', ! 42: 0 ! 43: }; ! 44: ! 45: ! 46: ! 47: ! 48: struct map ! 49: { ! 50: char name[MAXNAME+1]; /* attribute name */ ! 51: char ftype; /* attfrmt of file domain */ ! 52: char rtype; /* attfrmt of relation domain */ ! 53: int flen; /* attfrml of file domain */ ! 54: int rlen; /* attfrml of relation domain */ ! 55: int roffset; /* attoff of relation domain */ ! 56: int used; /* tag for duplicate checking */ ! 57: char *fdelim; /* pointer to list of file param delims */ ! 58: char *paramname; /* pointer to original parameter name */ ! 59: /* used for supplying domain name in case of error */ ! 60: }; ! 61: struct map Map[MAXMAP]; /* one entry for each user ! 62: specified domain in copy statement. */ ! 63: ! 64: int Mapcount; /* number of Map entries */ ! 65: ! 66: ! 67: DESC Des; /* descriptor for copied relation */ ! 68: ! 69: extern struct out_arg Out_arg; /* user defined formats for numeric output */ ! 70: ! 71: FILE *File_iop; /* i/o file pointer */ ! 72: char *Filename; /* pointer to file name */ ! 73: ! 74: int Into; /* into is one if this is a copy into file */ ! 75: ! 76: char Inbuf[BUFSIZ]; /* input holder */ ! 77: char Outbuf[BUFSIZ]; /* output holder */ ! 78: ! 79: long Tupcount; /* number of tuples processed */ ! 80: char *Relname; /* name of relation */ ! 81: long Duptuple; /* number of duplicate tuples */ ! 82: long Baddoms; /* number of domains with control chars */ ! 83: long Truncount; /* number of truncations on a c0 field */ ! 84: int Piped[2]; /* pipe descriptor for copy communication */ ! 85: char *Cpdomains[] = /* dummy domain names for copy "into" */ ! 86: { ! 87: "nl", "\n", ! 88: "tab", "\t", ! 89: "sp", " ", ! 90: "nul", "\0", ! 91: "null", "\0", ! 92: "comma", ",", ! 93: "colon", ":", ! 94: "dash", "-", ! 95: "lparen", "(", ! 96: "rparen", ")", ! 97: 0 ! 98: }; ! 99: ! 100: char Delimitor[] = ",\n\t"; /* default delims for c0 & d0 */ ! 101: ! 102: ! 103: ! 104: copy(pc,pv) ! 105: int pc; ! 106: PARM pv[]; ! 107: { ! 108: extern char *Usercode; ! 109: extern int Noupdt; ! 110: register int i, pid; ! 111: register char *cp; ! 112: int stat; ! 113: int copydone(); ! 114: int op; ! 115: ! 116: # ifdef xZTR1 ! 117: if (tTf(30,1)) ! 118: { ! 119: printf("entered copy\n"); ! 120: prvect(pc, pv); ! 121: } ! 122: # endif ! 123: Duptuple = 0; ! 124: Truncount = 0; ! 125: Tupcount = 0; ! 126: Baddoms = 0; ! 127: Relname = pv[0].pv_val.pv_str; ! 128: Into = (pv[pc-2].pv_val.pv_str[0] == 'i'); ! 129: Filename = pv[pc-1].pv_val.pv_str; ! 130: ! 131: /* relation must exist and not be a system relation */ ! 132: /* in addition a copy "from" can't be done if the user */ ! 133: /* doesn't own the relation */ ! 134: /* and furthermore it can't have an index */ ! 135: i = 0; /* assume all is well */ ! 136: if (op = openr(&Des, OR_WRITE, Relname)) ! 137: { ! 138: if (op == AMOPNVIEW_ERR) ! 139: i = NOCPVIEW; ! 140: else ! 141: { ! 142: if (op < 0) ! 143: syserr("COPY: openr 1 (%.14s) %d", Relname, op); ! 144: else ! 145: /* non-existant relation */ ! 146: i = NOEXIST; ! 147: } ! 148: } ! 149: else ! 150: { ! 151: if (Into) ! 152: { ! 153: if ((Des.reldum.relstat & S_PROTALL) ! 154: && (Des.reldum.relstat & S_PROTRET) ! 155: && !bequal(Usercode, Des.reldum.relowner, UCODE_SZ)) ! 156: i = RELPROTECT; ! 157: } ! 158: else ! 159: { ! 160: /* extra checking if this is a copy "from" */ ! 161: ! 162: /* must be owned by the user */ ! 163: if (!bequal(Usercode, Des.reldum.relowner, UCODE_SZ)) ! 164: i = NOTOWNER; ! 165: else ! 166: /* must be updateable */ ! 167: if ((Des.reldum.relstat & S_NOUPDT) && Noupdt) ! 168: i = NOUPDT; ! 169: else ! 170: /* must not be indexed */ ! 171: if (Des.reldum.relindxd > 0) ! 172: i = DESTINDEX; ! 173: } ! 174: } ! 175: if (i) ! 176: { ! 177: closer(&Des); ! 178: return (error(i, Relname, 0)); /* relation doesn't exist for this user */ ! 179: } ! 180: ! 181: /* check that file name begins with a "/" */ ! 182: cp = Filename; ! 183: while (*cp == ' ') ! 184: cp++; ! 185: if (*cp != '/') ! 186: { ! 187: closer(&Des); ! 188: return (error(FULLPATH, Filename, 0)); ! 189: } ! 190: ! 191: /* fill map structures with transfer information */ ! 192: if (i = mapfill(&pv[1])) ! 193: { ! 194: closer(&Des); ! 195: return (i); /* error in user semantics */ ! 196: } ! 197: ! 198: /* fork a child process which will run as the real user */ ! 199: /* that child will complete the copy and exit */ ! 200: if (pipe(Piped)) ! 201: syserr("copy:can't make pipe"); ! 202: if ((pid = fork()) < 0) ! 203: syserr("copy:can't fork"); ! 204: if (pid) ! 205: { ! 206: /* the ingres parent */ ! 207: close(Piped[1]); ! 208: ruboff(0); /* interrupts off */ ! 209: stat = fullwait(pid, "copy"); ! 210: if (read(Piped[0], &Des.reladds, 4) != 4) ! 211: syserr("copy:can't read pipe"); ! 212: close(Piped[0]); ! 213: closer(&Des); /* close the rel */ ! 214: rubon(); ! 215: /* if stat is != 0 then add on 5800 for error */ ! 216: if (stat) ! 217: stat += 5800; ! 218: return (stat); /* done */ ! 219: } ! 220: ! 221: /* the child. change to run as the real user */ ! 222: if (signal(SIGINT, SIG_IGN) != SIG_IGN) ! 223: signal(SIGINT, copydone); /* clean up on rubout */ ! 224: setuid(getuid()); ! 225: # ifndef xB_UNIX ! 226: setgid(getgid()); ! 227: # endif ! 228: if (Into) /* from relation into file */ ! 229: { ! 230: if ((File_iop = fopen(Filename, "w")) == NULL) /* create file for user */ ! 231: i = nferror(NOFILECRT, Filename, 0); /* cant create file */ ! 232: else ! 233: { ! 234: if (Lockrel) /* set a shared lock on relation*/ ! 235: setrll(A_SLP, Des.reltid.ltid, M_SHARE); ! 236: i = rel_file(); ! 237: } ! 238: } ! 239: else /* from UNIX file into relation */ ! 240: { ! 241: if ((File_iop = fopen(Filename, "r")) == NULL) ! 242: i = nferror(NOFILEOPN, Filename, 0); /* cant open user file */ ! 243: else ! 244: { ! 245: if (Lockrel) /* set an exclusive lock on relat*/ ! 246: setrll(A_SLP, Des.reltid.ltid, M_EXCL); ! 247: i = file_rel(); ! 248: if (Duptuple) ! 249: nferror(DUPTUPS, locv(Duptuple), 0); /* warning only */ ! 250: if (Baddoms) ! 251: nferror(BADDOMS, locv(Baddoms), 0); /* warning only */ ! 252: } ! 253: } ! 254: copydone(i); ! 255: } ! 256: /* ! 257: ** Finish up and exit after a copy or interrupt ! 258: ** ! 259: ** I is the return code. Since only a byte can be ! 260: ** returned, only the least significant 2 decimal ! 261: ** digits are returned. i is either 0 or a number like 58?? ! 262: */ ! 263: ! 264: copydone(i) ! 265: int i; ! 266: { ! 267: if (Lockrel) /* unlock relation */ ! 268: unlrl(Des.reltid.ltid); ! 269: if (Truncount) ! 270: nferror(TRUNCCHARS, locv(Truncount), 0); /* warning only */ ! 271: /* force the updates to be flushed */ ! 272: cleanrel(&Des); ! 273: if (File_iop) ! 274: fclose(File_iop); ! 275: if (write(Piped[1], &Des.reladds, 4) != 4) ! 276: syserr("copyc:can't writepipe"); ! 277: exit (i % 100); ! 278: } ! 279: /* ! 280: ** REL_FILE -- copy from relation to file ! 281: */ ! 282: ! 283: rel_file() ! 284: { ! 285: int j; ! 286: struct tup_id tid, limtid; ! 287: char *cp, save; ! 288: register int offset; ! 289: register int i; ! 290: register struct map *mp; ! 291: ! 292: /* set scan limits to scan the entire relation */ ! 293: if (find(&Des, NOKEY, &tid, &limtid)) ! 294: syserr("find error"); ! 295: ! 296: while ((i = get(&Des, &tid, &limtid, Inbuf, 1)) == 0) ! 297: { ! 298: mp = Map; ! 299: offset = 0; ! 300: for (i = 0; i < Mapcount; i++) ! 301: { ! 302: /* ! 303: ** For cases of char to numeric conversion, ! 304: ** there must be a null byte at the end of the ! 305: ** string. The character just past the current ! 306: ** domain is saved an a null byte inserted ! 307: */ ! 308: ! 309: cp = &Inbuf[mp->roffset + mp->rlen]; /* compute address */ ! 310: save = *cp; /* get the character */ ! 311: *cp = '\0'; /* insert a null */ ! 312: ! 313: /* ! 314: ** Special case, we want to copy the tid ! 315: */ ! 316: if ( mp->roffset == -1 ) ! 317: j = transfer(&tid,mp->rtype,mp->rlen, ! 318: mp->ftype,mp->flen,offset); ! 319: else ! 320: j = transfer(&Inbuf[mp->roffset], mp->rtype, ! 321: mp->rlen, mp->ftype, mp->flen, offset); ! 322: if (j) ! 323: { ! 324: /* bad ascii to numeric conversion or field length too small */ ! 325: return (nferror(j, mp->paramname, &Inbuf[mp->roffset], locv(Tupcount), Relname, Filename, 0)); ! 326: } ! 327: *cp = save; /* restore the saved character */ ! 328: offset += mp->flen; ! 329: mp++; ! 330: } ! 331: Tupcount++; ! 332: if (fwrite(Outbuf, 1, offset, File_iop) != offset) ! 333: syserr("copy:cant write to user file %s", Filename); ! 334: } ! 335: if (i < 0) ! 336: syserr("bad get from rel %d", i); ! 337: return (0); ! 338: } ! 339: /* ! 340: ** file_rel is called to transfer tuples from ! 341: ** the input file and append them to the relation ! 342: ** ! 343: ** Char domains are initialized to blank and numeric ! 344: ** domains are initialized to zero. ! 345: */ ! 346: ! 347: file_rel() ! 348: { ! 349: register int i, j; ! 350: register struct map *mp; ! 351: struct tup_id tid; ! 352: ! 353: clr_tuple(&Des, Outbuf); ! 354: ! 355: /* copy domains until an end of file or an error */ ! 356: for (;;) ! 357: { ! 358: mp = Map; ! 359: for (i = 0; i < Mapcount; i++) ! 360: { ! 361: if ((j = bread(mp)) <= 0) ! 362: { ! 363: if (j < 0) ! 364: { ! 365: i = 1; /* force an error */ ! 366: j = UNDETC0; /* unterminated string */ ! 367: } ! 368: else ! 369: j = UNEXEOF; /* end of file */ ! 370: if (i) /* error only if end of file during a tuple or unterminated string */ ! 371: { ! 372: i = nferror(j, mp->paramname, locv(Tupcount), Filename, Relname, 0); ! 373: } ! 374: return (i); ! 375: } ! 376: j = transfer(Inbuf, mp->ftype, mp->flen, mp->rtype, mp->rlen, mp->roffset); ! 377: if (j) ! 378: { ! 379: /* bad ascii to numeric or field length too small */ ! 380: return (nferror(j, mp->paramname, Inbuf, locv(Tupcount), Filename, Relname, 0)); ! 381: } ! 382: mp++; ! 383: } ! 384: Tupcount++; ! 385: if ((j = insert(&Des, &tid, Outbuf, 1)) < 0) ! 386: syserr("insert error %d rel=%s", j, Relname); ! 387: if (j == 1) ! 388: Duptuple++; ! 389: mp++; ! 390: } ! 391: /* ! 392: ** This statement was here -- i don'T think it does anything, but we'll see ! 393: ** return (0); ! 394: */ ! 395: } ! 396: /* ! 397: ** transfer copies data from "*in" to ! 398: ** Outbuf doing conversions whenever ! 399: ** necessary ! 400: */ ! 401: ! 402: transfer(in, sf, sl, df, dl, doff) ! 403: ANYTYPE *in; /* pointer to input chars */ ! 404: char sf; /* source format */ ! 405: int sl; /* source length */ ! 406: char df; /* destination format */ ! 407: int dl; /* destination length */ ! 408: int doff; /* destination offset */ ! 409: { ! 410: register char *outp; ! 411: register ANYTYPE *inp; ! 412: register int i; ! 413: int j; ! 414: short smalli; ! 415: char temp[MAXFIELD]; /* holds char during conversions to ascii */ ! 416: float f; ! 417: double d; ! 418: long l; ! 419: ! 420: ! 421: outp = &Outbuf[doff]; ! 422: inp = in; ! 423: ! 424: if (sf == DUMMY) ! 425: /* if source format is a dummy fields then ! 426: nothing else need be done */ ! 427: return (0); ! 428: ! 429: if (df == DUMMY) ! 430: { ! 431: /* fill field with dummy domain character */ ! 432: i = dl; /* i equals the number of chars */ ! 433: while (i--) ! 434: *outp++ = sf; /* sf holds dummy char */ ! 435: return (0); ! 436: } ! 437: ! 438: if (sf != CHAR) ! 439: { ! 440: if (df == CHAR) /* numeric to char conversion */ ! 441: { ! 442: switch (sl) ! 443: { ! 444: /* int of size 1 or 2 */ ! 445: case 1: ! 446: itoa(inp->i1type, temp); ! 447: break; ! 448: ! 449: case 2: ! 450: itoa(inp->i2type, temp); /* convert to ascii */ ! 451: break; ! 452: ! 453: /* int or float of size 4 */ ! 454: case 4: ! 455: if (sf == INT) ! 456: { ! 457: smove(locv(inp->i4type), temp); /* convert and copy */ ! 458: } ! 459: ! 460: else ! 461: { ! 462: ftoa(inp->f4type, temp, dl, Out_arg.f4prec, Out_arg.f4style); ! 463: } ! 464: break; ! 465: ! 466: /* float of size 8 */ ! 467: case 8: ! 468: ftoa(inp->f8type, temp, dl, Out_arg.f8prec, Out_arg.f8style); ! 469: break; ! 470: ! 471: /* there is no possible default */ ! 472: default: ! 473: syserr("bad domain length %d",sl); ! 474: } ! 475: ! 476: j = length(temp); ! 477: if ((i = dl - j) < 0) ! 478: return (5808); /* field won't fit */ ! 479: ! 480: /* blank pad from left. Number will be right justified */ ! 481: while (i--) ! 482: *outp++ = ' '; ! 483: ! 484: bmove(temp, outp, j); ! 485: return (0); ! 486: } ! 487: ! 488: if (convert(inp, outp, sf, sl, df, dl)) /* numeric to numeric transfer */ ! 489: return (DOMTOOSMALL); /* numeric truncation error */ ! 490: return (0); ! 491: } ! 492: ! 493: /* character to numeric conversion */ ! 494: /* and character to character conversion */ ! 495: switch (df) ! 496: { ! 497: ! 498: case CHAR: ! 499: i = sl; ! 500: if (!i) ! 501: { ! 502: i = length(inp->c0type); ! 503: } ! 504: if (i > dl) ! 505: i = dl; ! 506: if (charmove(inp->c0type, outp, i)) ! 507: Baddoms++; ! 508: for (outp += i; i<dl; i++) ! 509: *outp++ = ' '; ! 510: return (0); ! 511: ! 512: case FLOAT: ! 513: if (atof(inp->c0type, &d)) ! 514: return (BADINPUT); /* bad conversion to numeric */ ! 515: if (dl == 8) ! 516: bmove(&d, outp, dl); ! 517: else ! 518: { ! 519: f = d; /* f8 to f4 conversion */ ! 520: bmove(&f, outp, dl); ! 521: } ! 522: return (0); ! 523: ! 524: case INT: ! 525: if (dl == 4) ! 526: { ! 527: if (atol(inp->c0type, &l)) ! 528: return (5809); ! 529: bmove(&l, outp, 4); ! 530: return (0); ! 531: } ! 532: smalli = atoi(inp->c0type); ! 533: if ((dl == 1) && ((smalli < -128) || (smalli > 127))) ! 534: return (5809); ! 535: bmove(&smalli, outp, dl); ! 536: return (0); ! 537: } ! 538: } ! 539: /* ! 540: ** moves a character string from "in" ! 541: ** to "out" removing any control characters. ! 542: ** returns true if any control characters were found ! 543: */ ! 544: ! 545: charmove(in, out, length) ! 546: char *in, *out; ! 547: int length; ! 548: { ! 549: register char *ip, *op; ! 550: register int l; ! 551: int bad; ! 552: ! 553: bad = FALSE; ! 554: ip = in; ! 555: op = out; ! 556: l = length; ! 557: ! 558: while (l--) ! 559: if ((*op++ = *ip++) < ' ') ! 560: { ! 561: *(op-1) = ' '; ! 562: bad = TRUE; ! 563: } ! 564: return (bad); ! 565: } ! 566: /* ! 567: ** Mapfill fills the Map structure with the list ! 568: ** of user supplied attributes. It then reads ! 569: ** the list of relation attributes and checks ! 570: ** for matching attribute names. ! 571: ** ! 572: ** if an error occures then mapfill returns -1 ! 573: ** else it returns 0 ! 574: ** ! 575: ** Mapfill performs special processing on ! 576: ** dummy domains. ! 577: ** ! 578: ** If no user attributes are given, then "given"=FALSE ! 579: ** and each attribute in the relation is set up to be ! 580: ** copied in the formats and order in which they ! 581: ** exist in the relation ! 582: */ ! 583: ! 584: mapfill(aptr) ! 585: PARM aptr[]; ! 586: { ! 587: register PARM *ap; ! 588: register struct map *mp; ! 589: register int i; ! 590: char *fp; ! 591: extern DESC Attdes; ! 592: struct attribute att; ! 593: struct tup_id tid, limtid; ! 594: int given, cnt; ! 595: char *zcheck(); ! 596: char *dumvalue(); ! 597: ! 598: Mapcount = 0; ! 599: mp = Map; ! 600: ap = aptr; ! 601: ! 602: /* Gather list of user supplied attributes */ ! 603: ! 604: while (*(ap->pv_val.pv_str) != '\0') ! 605: { ! 606: /* check for overflow */ ! 607: if (Mapcount == MAXMAP) ! 608: return (error(TOOMANYATTR, 0)); /* more than MAXMAP specifiers */ ! 609: ! 610: mp->paramname = (ap->pv_val).pv_str; /* save pointer to user supplied name */ ! 611: pmove(((ap++)->pv_val).pv_str, mp->name, MAXNAME, ' '); ! 612: fp = ((ap++)->pv_val).pv_str; /* fp points to format string */ ! 613: mp->used = 0; ! 614: mp->rlen = 0; /* zero in case this is a dummy domain */ ! 615: mp->roffset = 0; ! 616: mp->fdelim = 0; ! 617: /* check domain type in *fp */ ! 618: switch (*fp++) ! 619: { ! 620: ! 621: case 'c': ! 622: i = CHAR; ! 623: if ((mp->fdelim = zcheck(fp)) == 0) ! 624: return (-1); /* bad delimitor */ ! 625: break; ! 626: ! 627: case 'f': ! 628: i = FLOAT; ! 629: break; ! 630: ! 631: case 'i': ! 632: i = INT; ! 633: break; ! 634: ! 635: case DUMMY: ! 636: i = DUMMY; ! 637: if ((mp->fdelim = zcheck(fp)) == 0) ! 638: return (-1); ! 639: break; ! 640: ! 641: default: ! 642: return (error(BADATTRTYPE, mp->paramname, --fp, 0)); ! 643: } ! 644: mp->ftype = i; ! 645: ! 646: ! 647: /* convert format length to binary */ ! 648: mp->flen = atoi(fp); ! 649: if (mp->flen < 0 || ! 650: mp->flen > 511 || ! 651: (mp->ftype == FLOAT && mp->flen != 4 && mp->flen != 8) || ! 652: (mp->ftype == INT && mp->flen != 1 && mp->flen != 2 && mp->flen != 4)) ! 653: { ! 654: return (error(BADATTRLEN, mp->paramname, --fp, 0)); /* bad length for attribute */ ! 655: } ! 656: ! 657: /* process dummy domain if any */ ! 658: if (Into && mp->ftype == DUMMY && mp->flen) ! 659: { ! 660: if ((fp = dumvalue(mp->paramname)) == 0) ! 661: return (5807); /* bad dummy name */ ! 662: mp->rtype = *fp; /* use first char of string */ ! 663: } ! 664: ! 665: /* check for format of type "c0delim" on copy "into" */ ! 666: if (Into && mp->flen == 0 && mp->fdelim != Delimitor) ! 667: { ! 668: fp = mp->fdelim; ! 669: ! 670: /* is there room for a dummy domain? */ ! 671: mp++; ! 672: if (++Mapcount == MAXMAP) ! 673: return (error(TOOMANYATTR, 0)); /* no room */ ! 674: ! 675: /* create a dummy entry */ ! 676: mp->ftype = DUMMY; ! 677: mp->flen = 1; ! 678: mp->rtype = *fp; ! 679: mp->roffset = mp->rlen = 0; ! 680: } ! 681: ! 682: mp++; ! 683: Mapcount++; ! 684: } ! 685: /* if no atributes were given, set flag */ ! 686: if (Mapcount) ! 687: given = TRUE; ! 688: else ! 689: given = FALSE; ! 690: ! 691: /* open attribute relation and prepare for scan */ ! 692: opencatalog("attribute", OR_READ); ! 693: ! 694: setkey(&Attdes, &att, Des.reldum.relid, ATTRELID); ! 695: setkey(&Attdes, &att, Des.reldum.relowner, ATTOWNER); ! 696: ! 697: if (find(&Attdes, EXACTKEY, &tid, &limtid, &att)) ! 698: syserr("find error for att-rel"); ! 699: ! 700: /* scan Map for each relation attribute */ ! 701: while ((i = get(&Attdes, &tid, &limtid, &att, 1)) == 0) ! 702: { ! 703: if (!bequal(&Des, &att, MAXNAME+2)) ! 704: continue; ! 705: /* if no user attributes were supplied, fake an entry */ ! 706: if (!given) ! 707: { ! 708: Mapcount++; ! 709: mp = &Map[att.attid -1]; ! 710: mp->rtype = mp->ftype = att.attfrmt; ! 711: mp->rlen = mp->flen = att.attfrml & I1MASK; ! 712: mp->roffset = att.attoff; ! 713: mp->used = 1; ! 714: mp->paramname = mp->name; /* point to name */ ! 715: bmove(att.attname, mp->name, MAXNAME); /* copy name */ ! 716: continue; ! 717: } ! 718: mp = Map; ! 719: ! 720: /* check each user domain for match with relation domain */ ! 721: for (i = Mapcount; i--; mp++) ! 722: { ! 723: if (mp->ftype == DUMMY) ! 724: continue; /* ignore dummy */ ! 725: if (!bequal(mp->name, att.attname, 12)) ! 726: continue; ! 727: ! 728: mp->rtype = att.attfrmt; ! 729: mp->rlen = att.attfrml & I1MASK; ! 730: mp->roffset = att.attoff; ! 731: mp->used++; ! 732: ! 733: /* check for special case of C0 in a copy "into" */ ! 734: if (Into && (mp->flen == 0) && mp->ftype == CHAR) ! 735: { ! 736: switch (mp->rtype) ! 737: { ! 738: case CHAR: ! 739: mp->flen = mp->rlen; ! 740: break; ! 741: ! 742: case INT: ! 743: switch (mp->rlen) ! 744: { ! 745: ! 746: case 1: ! 747: mp->flen = Out_arg.i1width; ! 748: break; ! 749: ! 750: case 2: ! 751: mp->flen = Out_arg.i2width; ! 752: break; ! 753: ! 754: case 4: ! 755: mp->flen = Out_arg.i4width; ! 756: } ! 757: break; ! 758: ! 759: case FLOAT: ! 760: if (mp->rlen == 4) ! 761: mp->flen = Out_arg.f4width; ! 762: else ! 763: mp->flen = Out_arg.f8width; ! 764: } ! 765: } ! 766: /* if this is a copy "from" then break ! 767: otherwise continue. In a copy "into" ! 768: an attribute might be copied more than once */ ! 769: if (!Into) ! 770: break; ! 771: } ! 772: } ! 773: if (i < 0) ! 774: syserr("bad get from att-rel %d", i); ! 775: ! 776: /* check that all user domains have been identified */ ! 777: cnt = 0; ! 778: mp = Map; ! 779: for (i = Mapcount; i--; mp++) ! 780: { ! 781: cnt += mp->flen; ! 782: if (mp->ftype == DUMMY) ! 783: continue; ! 784: if (!mp->used) ! 785: { ! 786: if ( Into && bequal(mp->name,"tid ",12) ) ! 787: { ! 788: mp->flen = 4; ! 789: mp->rtype = INT; ! 790: mp->rlen = 4; ! 791: mp->roffset = -1; ! 792: mp->used++; ! 793: } ! 794: else ! 795: return (error(ATTRNOEXIST, mp->paramname, Relname, 0)); /* unrecognizable domain name */ ! 796: } ! 797: } ! 798: /* check that copy into doesn't exceed buffer size */ ! 799: if (Into && cnt > BUFSIZ) ! 800: return (error(FILETOOWIDE, 0)); /* cnt too large */ ! 801: return (0); ! 802: } ! 803: /* ! 804: ** BREAD ! 805: */ ! 806: ! 807: bread(mp) ! 808: struct map *mp; ! 809: { ! 810: register int count, i; ! 811: register char *inp; ! 812: char *dl; ! 813: int esc; /* escape flag */ ! 814: ! 815: count = mp->flen; ! 816: inp = Inbuf; ! 817: ! 818: if (count) ! 819: { ! 820: /* block mode. read characters */ ! 821: i = fread(inp, 1, count, File_iop); ! 822: ! 823: /* null terminate */ ! 824: *(inp + count) = '\0'; ! 825: ! 826: return (i == count); /* true -> normal, false ->eof */ ! 827: } ! 828: ! 829: /* string mode read */ ! 830: /* ! 831: ** Determine the maximum size the C0 field being read can be. ! 832: ** In the case where it is being copied into a CHAR field, then ! 833: ** the size is that of the char field (+1 for the delimitor). ! 834: ** In the case of a numeric, it is limited only by the size of the ! 835: ** buffer area. ! 836: */ ! 837: count = mp->rtype == CHAR ? mp->rlen + 1 : BUFSIZ; ! 838: esc = FALSE; ! 839: ! 840: for (;;) ! 841: { ! 842: if ((i = getc(File_iop)) == EOF) ! 843: return (inp == Inbuf ? 0 : -1); /* -1 -> unexpected EOF, 0 -> normal EOF */ ! 844: ! 845: if (count > 0) ! 846: { ! 847: count--; ! 848: *inp++ = i; ! 849: } ! 850: else ! 851: { ! 852: if (count == 0) ! 853: { ! 854: /* determine type of overflow */ ! 855: if (mp->rtype == CHAR) ! 856: { ! 857: Truncount++; ! 858: count--; /* read until delim */ ! 859: } ! 860: else ! 861: { ! 862: return (-1); ! 863: } ! 864: } ! 865: } ! 866: if (esc) ! 867: { ! 868: esc = FALSE; ! 869: continue; ! 870: } ! 871: if (i == ESCAPE) ! 872: { ! 873: esc = TRUE; ! 874: /* ! 875: ** If esc was stored, back it up. ! 876: */ ! 877: if (count >= 0) ! 878: { ! 879: inp--; /* remove escape char */ ! 880: count++; /* restore counter */ ! 881: } ! 882: } ! 883: else ! 884: { ! 885: for (dl = mp->fdelim; *dl; dl++) ! 886: if (*dl == i) ! 887: { ! 888: *(inp-1) = '\0'; ! 889: return (1); ! 890: } ! 891: } ! 892: } ! 893: } ! 894: /* ! 895: ** Look for the existence of a param of the ! 896: ** form "0nl" or "00comma" etc. ! 897: ** ! 898: ** Returns the correct delim list or 0 ! 899: ** if there was a user error ! 900: ** ! 901: ** If successful, a null is inserted at the ! 902: ** rightmost '0' so the subsequent atoi will work. ! 903: */ ! 904: ! 905: char * ! 906: zcheck(param) ! 907: char *param; ! 908: { ! 909: register char *np, *ret; ! 910: ! 911: np = param; ! 912: ret = Delimitor; /* assume default delimitors */ ! 913: ! 914: if (*np++ == '0') ! 915: { ! 916: /* we have a starting zero. trim the rest */ ! 917: while (*np == '0') ! 918: np++; ! 919: ! 920: if (*np > '9' || (*np < '0' && *np >= ' ')) ! 921: { ! 922: /* we have a special delim on a 0 width field */ ! 923: if (ret = dumvalue(np)) ! 924: *(--np) = '\0'; /* ! 925: ** end string before delim ! 926: ** Do not alter delimitor but ! 927: ** instead destroy last '0'. ! 928: */ ! 929: } ! 930: } ! 931: return (ret); ! 932: } ! 933: /* ! 934: ** Search list of valid dummy names looking ! 935: ** for 'name'. If 'name' is a single char ! 936: ** then use just that name else it is ! 937: ** an error if the name is not found ! 938: */ ! 939: ! 940: char * ! 941: dumvalue(name) ! 942: char *name; ! 943: { ! 944: register char **dp, *np, *ret; ! 945: ! 946: dp = Cpdomains; /* get list of valid dummy names */ ! 947: np = name; ! 948: ret = 0; ! 949: ! 950: /* first look for a matching key word */ ! 951: while (*dp) ! 952: { ! 953: if (sequal(np, *dp++)) ! 954: { ! 955: ret = *dp; ! 956: break; ! 957: } ! 958: dp++; ! 959: } ! 960: ! 961: /* If single char, use that char */ ! 962: if (length(np) == 1) ! 963: ret = np; /* use first char of name */ ! 964: if (ret == 0) ! 965: error(UNRECDUMMY, np, 0); ! 966: ! 967: return (ret); ! 968: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.