static void path_raw(struct net_seq_stream *net, char *url, char *hdr, char *data, int dlen) { chprintf((BaseSequentialStream *)net, "HTTP/1.1 200 OK\r\nContent-type: text/plain\r\n\r\n"); data_dump((BaseSequentialStream *)net); }
int getlabel( CIFBLK *cif, DASD_VOL_LABEL *glbuf, int verbose) { int len, rc; void *plabel; if (verbose) fprintf(stderr, "getlabel reading volume label\n"); rc = read_block(cif, 0, 0, 3, NULL, NULL, (void *) &plabel, &len); if (rc) { fprintf(stderr, "getlabel error reading volume label, rc %d\n", rc); return 1; } if (len != sizeof(DASD_VOL_LABEL)) { fprintf(stderr, "getlabel error: volume label %d, not 80 bytes long\n", len); return 2; } memcpy((void *)glbuf, plabel, sizeof(DASD_VOL_LABEL)); if (verbose > 1) { fprintf(stderr, "getlabel volume label\n"); data_dump(glbuf, len); } return 0; } /* getlabel */
void list_dump(list_t * self, void data_dump(void *)) { unsigned i; assert(self && data_dump); for (i = 0; i < self->length; i++) data_dump(self->elements[i]); }
/* Dump a UDP header */ void udp_dump(unsigned char *data, int length, int hexdump) { int hdr_length; int source; int dest; hdr_length = get16(data + 4); source = get16(data + 0); dest = get16(data + 2); lprintf(T_PROTOCOL, "UDP:"); lprintf(T_TCPHDR, " len %d %s->", hdr_length, servname(source, "udp")); lprintf(T_TCPHDR, "%s", servname(dest, "udp")); if (hdr_length > UDPHDR) { length -= UDPHDR; data += UDPHDR; switch (dest) { case RIP_PORT: lprintf(T_TCPHDR, "\n"); rip_dump(data, length); break; default: lprintf(T_TCPHDR, " Data %d\n", length); data_dump(data, length, hexdump); break; } } }
/*-------------------------------------------------------------------*/ BYTE *show_ckd_key(CKDDASD_RECHDR *rh, BYTE *buf, int trk, int xop) { if (rh->klen && xop) { fprintf(stderr, MSG( HHC02606, "I", trk, rh->rec, rh->rec, rh->klen ) ); data_dump(buf, rh->klen); } return (BYTE *)buf + rh->klen; /* skip past KEY field */ }
/* Newline appended to message */ void snap(char *msg, void *data, int len) { if (msg != NULL) fprintf(stderr, "%s\n", msg); data_dump(data, len); if (pausesnap) { fprintf(stderr, MSG( HHC02601, "I" ) ); (void)getc(stdin); } }
/*-------------------------------------------------------------------*/ BYTE *show_ckd_key(CKDDASD_RECHDR *rh, BYTE *buf, int trk, int xop) { if (rh->klen && xop) { fprintf(stdout, "\nTrack %d R%d KEY (%d bytes)\n", trk, rh->rec, rh->klen); data_dump(buf, rh->klen); } return (BYTE *)buf + rh->klen; /* skip past KEY field */ }
/*-------------------------------------------------------------------*/ BYTE *show_ckd_data(CKDDASD_RECHDR *rh, BYTE *buf, int trk, int xop) { int dl; dl = (rh->dlen[0] << 8) | (rh->dlen[1]); if (dl && xop) { fprintf(stderr, MSG( HHC02607, "I", trk, rh->rec, rh->rec, dl ) ); data_dump(buf, dl); } return buf + dl; /* skip past DATA field */ }
/* Newline appended to message */ void snap(char *msg, void *data, int len) { int x; if (msg != NULL) fprintf(stdout, "%s\n", msg); data_dump(data, len); if (pausesnap) { fprintf(stdout, "Press enter to continue\n"); x = getc(stdin); } }
/*-------------------------------------------------------------------*/ BYTE *show_ckd_data(CKDDASD_RECHDR *rh, BYTE *buf, int trk, int xop) { int dl; dl = (rh->dlen[0] << 8) | (rh->dlen[1]); if (dl && xop) { fprintf(stdout, "\nTrack %d R%d DATA (%d bytes)\n", trk, rh->rec, dl); data_dump(buf, dl); } return buf + dl; /* skip past DATA field */ }
int getF3dscb( CIFBLK *cif, BYTE *f3cchhr, FORMAT3_DSCB *f3dscb, int verbose) { int cyl, head, rec, rc; void *f3key, *f3data; int f3kl, f3dl; cyl = (f3cchhr[0] << 8) | f3cchhr[1]; head = (f3cchhr[2] << 8) | f3cchhr[3]; rec = f3cchhr[4]; if (verbose) fprintf(stderr, "getF3dscb reading F3 DSCB " "cyl %d head %d rec %d\n", cyl, head, rec); rc = read_block (cif, cyl, head, rec, (void *)&f3key, &f3kl, (void *)&f3data, &f3dl); if (rc) { fprintf(stderr, "getF3dscb error reading F3 DSCB, rc %d\n", rc); return 1; } if ((f3kl != 44) || (f3dl != 96)) { fprintf(stderr, "getF3dscb bad key %d or data %d length\n", f3kl, f3dl); return 2; } memcpy((void *) &f3dscb->ds3keyid, f3key, f3kl); // copy F3 key to buffer memcpy((void *) ((BYTE*)f3dscb + f3kl), f3data, f3dl); // copy F3 data to buffer if (verbose > 1) { fprintf(stderr, "getF3dscb F3 DSCB\n"); data_dump((void *) f3dscb, sizeof(FORMAT3_DSCB)); } // Verify DS3FMTID byte = x'F3' // Do this after copying data to caller's buffer so we can use struct fields // rather than having to calculate offset to verified data; little harm done // if it doesn't verify since we're toast if it's bad. if (f3dscb->ds3fmtid != 0xf3) { fprintf(stderr, "getF3dscb " "F3 DSCB format id byte invalid (DS3IDFMT) %2.2X\n", f3dscb->ds3fmtid); return 2; } return 0; } /* getF3dscb */
/* ---- */ int main (int argc, char *argv[]) { if (argc < 2) { print_usage (); exit (1); } if (strcmp (argv[1], "vc") == 0) { verify_checksum (argc - 2, argv + 2); } else if (strcmp (argv[1], "datadump") == 0) { data_dump (argc - 2, argv + 2); } else if (strcmp (argv[1], "createlog") == 0) { createlog (argc - 2, argv + 2); } else if (strcmp (argv[1], "deletelog") == 0) { deletelog (argc - 2, argv + 2); } else if (strcmp (argv[1], "synclog") == 0) { synclog (argc - 2, argv + 2); } else if (strcmp (argv[1], "infomem") == 0) { infomem (argc - 2, argv + 2); } else { print_usage (); exit (1); } }
int fbcopy( FILE *fout, CIFBLK *cif, DADSM *dadsm, int tran, int verbose) { FORMAT1_DSCB *f1dscb = &dadsm->f1buf; DSXTENT extent[MAX_EXTENTS]; int rc, trk = 0, trkconv = 999, rec = 1; int cyl = 0, head = 0, rc_rb, len, offset; int rc_copy = 0; int recs_written = 0, lrecl, num_extents; int lstartrack = 0, lstarrec = 0, lstarvalid = 0; BYTE *buffer; char *pascii = NULL; char zdsn[sizeof(f1dscb->ds1dsnam) + 1]; // ascii dsn // Kludge to avoid rewriting this code (for now): memcpy(&extent, (void *)&(dadsm->f1ext), sizeof(extent)); num_extents = f1dscb->ds1noepv; lrecl = (f1dscb->ds1lrecl[0] << 8) | (f1dscb->ds1lrecl[1]); if (absvalid) { strcpy(zdsn, argdsn); if (debug) fprintf(stderr, "fbcopy absvalid\n"); } else { make_asciiz(zdsn, sizeof(zdsn), f1dscb->ds1dsnam, sizeof(f1dscb->ds1dsnam)); if ((f1dscb->ds1lstar[0] !=0) || (f1dscb->ds1lstar[1] != 0) || (f1dscb->ds1lstar[2] != 0)) { lstartrack = (f1dscb->ds1lstar[0] << 8) | (f1dscb->ds1lstar[1]); lstarrec = f1dscb->ds1lstar[2]; lstarvalid = 1; // DS1LSTAR valid } } if (debug) { fprintf(stderr, "fbcopy zdsn %s\n", zdsn); fprintf(stderr, "fbcopy num_extents %d\n", num_extents); fprintf(stderr, "fbcopy lrecl %d\n", lrecl); fprintf(stderr, "fbcopy F1 DSCB\n"); data_dump(f1dscb, sizeof(FORMAT1_DSCB)); sayext(num_extents, (void *)&extent); } if (verbose) // DS1LSTAR = last block written TTR fprintf(stderr, "fbcopy DS1LSTAR %2.2X%2.2X%2.2X lstartrack %d " "lstarrec %d lstarvalid %d\n", f1dscb->ds1lstar[0], f1dscb->ds1lstar[1], f1dscb->ds1lstar[2], lstartrack, lstarrec, lstarvalid); if (tran) { // need ASCII translation buffer? pascii = malloc(lrecl + 1); if (pascii == NULL) { fprintf(stderr, "fbcopy unable to allocate ascii buffer\n"); return -1; } } while (1) { // output records until something stops us // Honor DS1LSTAR when valid if ((lstarvalid) && (trk == lstartrack) && (rec > lstarrec)) { if (verbose) fprintf(stderr, "fbcopy DS1LSTAR indicates EOF\n" "fbcopy DS1LSTAR %2.2X%2.2X%2.2X " "track %d record %d\n", f1dscb->ds1lstar[0], f1dscb->ds1lstar[1], f1dscb->ds1lstar[2], trk, rec); rc_copy = recs_written; break; } // Convert TT to CCHH for upcoming read_block call if (trkconv != trk) { // avoid converting for each block trkconv = trk; // current track converted rc = convert_tt(trk, num_extents, extent, cif->heads, &cyl, &head); if (rc < 0) { fprintf(stderr, "fbcopy convert_tt track %5.5d, rc %d\n", trk, rc); if (absvalid) rc_copy = recs_written; else rc_copy = -1; break; } if (verbose > 1) fprintf(stderr, "fbcopy convert TT %5.5d CCHH %4.4X %4.4X\n", trk, cyl, head); } // Read block from dasd if (verbose > 2) fprintf(stderr, "fbcopy reading track %d " "record %d CCHHR = %4.4X %4.4X %2.2X\n", trk, rec, cyl, head, rec); rc_rb = read_block(cif, cyl, head, rec, NULL, NULL, &buffer, &len); if (rc_rb < 0) { // error fprintf(stderr, "fbcopy error reading %s, rc %d\n", zdsn, rc_rb); rc_copy = -1; break; } // Handle end of track return from read_block if (rc_rb > 0) { // end of track if (verbose > 2) fprintf(stderr, "fbcopy End Of Track %d rec %d\n", trk, rec); trk++; // next track rec = 1; // record 1 on new track continue; } // Check for dataset EOF if (len == 0) { // EOF if (verbose) fprintf(stderr, "fbcopy EOF track %5.5d rec %d\n", trk, rec); if (absvalid) { // capture as much -abs data as possible if (verbose) fprintf(stderr, "fbcopy ignoring -abs EOF\n"); } else { rc_copy = recs_written; break; } } if (verbose > 3) fprintf(stderr, "fbcopy read %d bytes\n", len); if (verbose > 2) { data_dump(buffer, len); fprintf(stderr, "\n"); } // Deblock input dasd block, write records to output dataset for (offset = 0; offset < len; offset += lrecl) { if (verbose > 3) { fprintf(stderr, "fbcopy offset %d length %d rec %d\n", offset, lrecl, recs_written); } if (tran) { // ASCII output memset(pascii, 0, lrecl + 1); make_asciiz(pascii, lrecl + 1, buffer + offset, lrecl); if (verbose > 4) { fprintf(stderr, "fbcopy buffer offset %d rec %d\n", offset, rec); data_dump(buffer + offset, lrecl); } if (verbose > 3) { fprintf(stderr, "->%s<-\n", pascii); data_dump(pascii, lrecl); } fprintf(fout, "%s\n", pascii); } else { // EBCDIC output if (verbose > 3) { fprintf(stderr, "fbcopy EBCDIC buffer\n"); data_dump(buffer + offset, lrecl); } fwrite(buffer + offset, lrecl, 1, fout); } if (ferror(fout)) { fprintf(stderr, "fbcopy error writing %s\n", zdsn); fprintf(stderr, "%s\n", strerror(errno)); rc_copy = -1; } recs_written++; } if (rc_copy != 0) break; else rec++; // next record on track } /* while (1) */ if (pascii) free(pascii); // release ASCII conversion buffer return rc_copy; } /* fbcopy */
int main() { unsigned char *datagram; unsigned char *cksum_pack; unsigned short check; int raw_fd, sock_fd; struct sockaddr_in addr, server; struct udp_hdr udph; struct pseudo_header psdh; raw_fd = socket(AF_INET, SOCK_RAW, IPPROTO_UDP); if (raw_fd < 0){ perror("socket"); exit(EXIT_FAILURE); } sock_fd = socket(AF_INET, SOCK_DGRAM, 0); if (sock_fd < 0){ perror("socket"); exit(EXIT_FAILURE); } datagram = malloc(DATAGRAM_SIZE * sizeof(unsigned char)); if (datagram == NULL){ perror("malloc"); exit(EXIT_FAILURE); } memset(datagram, 0, DATAGRAM_SIZE); memset(&server, 0, sizeof(server)); addr.sin_family = AF_INET; addr.sin_addr.s_addr = inet_addr(IPADDR_SER); addr.sin_port = htons(PORT); server.sin_family = AF_INET; server.sin_addr.s_addr = inet_addr(IPADDR_SER); server.sin_port = htons(PORT_SER); if (bind(sock_fd, (struct sockaddr *)&addr, sizeof(struct sockaddr)) < 0){ perror("bind"); free(datagram); exit(EXIT_FAILURE); } //pseudo header init psdh.source_ip = inet_addr(IPADDR); psdh.dest_ip = inet_addr(IPADDR_SER); psdh.zero = 0; psdh.protocol = IPPROTO_UDP; psdh.seg_len = htons(UDP_H_SIZE + DATA_SIZE); //udp header init udph.source_port = htons(PORT); udph.dest_port = htons(PORT_SER); udph.length = htons(UDP_H_SIZE + DATA_SIZE); udph.cksum = 0; //checksum calc cksum_pack = malloc((sizeof(struct pseudo_header) + DATAGRAM_SIZE) * sizeof(unsigned char)); if (cksum_pack == NULL){ perror("malloc"); free(datagram); exit(EXIT_FAILURE); } memcpy(cksum_pack, (unsigned char *)&psdh, sizeof(struct pseudo_header)); memcpy(cksum_pack + sizeof(struct pseudo_header), (unsigned char *) &udph, UDP_H_SIZE); *(cksum_pack + sizeof(struct pseudo_header) + UDP_H_SIZE) = 'r'; *(cksum_pack + sizeof(struct pseudo_header) + UDP_H_SIZE + 1) = 'a'; *(cksum_pack + sizeof(struct pseudo_header) + UDP_H_SIZE + 2) = 'w'; #ifdef DEBUG data_dump((unsigned char *)&psdh, sizeof(struct pseudo_header)); data_dump(cksum_pack, sizeof(struct pseudo_header) + UDP_H_SIZE + DATA_SIZE); #endif check = crc16(cksum_pack, sizeof(struct pseudo_header) + UDP_H_SIZE + 3); #ifdef DEBUG printf("\ncheck: %.2X\n", check); #endif udph.cksum = check; memcpy(datagram, (unsigned char *)&udph, UDP_H_SIZE); *(datagram + UDP_H_SIZE) = 'r'; *(datagram + UDP_H_SIZE + 1) = 'a'; *(datagram + UDP_H_SIZE + 2) = 'w'; data_dump(datagram, UDP_H_SIZE + 3); if (sendto(raw_fd, datagram, DATAGRAM_SIZE, 0, (struct sockaddr *)&server, sizeof(server)) == -1){ perror("sendto"); } free(datagram); free(cksum_pack); close(raw_fd); }
void showf1( FILE *fmsg, FORMAT1_DSCB *f1dscb, DSXTENT extent[], int verbose) { int i, dsorg, lrecl, blksize, volseq, x, y, num_extents; char volser[sizeof(f1dscb->ds1dssn) + 1]; char dsn[sizeof(f1dscb->ds1dsnam) + 1]; char txtcredt[9]; // creation date char txtexpdt[9] = "(n/a)"; // expiration date char txtscr[20]; char txtsyscd[14]; char txtdsorg[5] = ""; // dsorg text char txtrecfm[5] = ""; // recfm text if (verbose > 2) { fprintf(fmsg, "showf1 F1 DSCB\n"); data_dump(f1dscb, sizeof(FORMAT1_DSCB)); } make_asciiz(dsn, sizeof(dsn), f1dscb->ds1dsnam, sizeof(f1dscb->ds1dsnam)); make_asciiz(volser, sizeof(volser), f1dscb->ds1dssn, sizeof(f1dscb->ds1dssn)); volseq = (f1dscb->ds1volsq[0] << 8) | (f1dscb->ds1volsq[1]); x = f1dscb->ds1credt[0] + 1900; y = (f1dscb->ds1credt[1] << 8) | f1dscb->ds1credt[2]; sprintf(txtcredt, "%4.4d", x); strcat(txtcredt, "."); sprintf(txtscr, "%3.3d", y); strcat(txtcredt, txtscr); if (f1dscb->ds1expdt[0] || f1dscb->ds1expdt[1] || f1dscb->ds1expdt[2]) { x = f1dscb->ds1expdt[0] + 1900; y = (f1dscb->ds1expdt[1] << 8) | f1dscb->ds1expdt[2]; sprintf(txtexpdt, "%4.4d", x); strcat(txtexpdt, "."); sprintf(txtscr, ".%3.3d", y); strcat(txtexpdt, txtscr); } num_extents = f1dscb->ds1noepv; // Field ignored: ds1nobdb (# bytes used in last PDS dir blk) make_asciiz(txtsyscd, sizeof(txtsyscd), f1dscb->ds1syscd, sizeof(f1dscb->ds1syscd)); dsorg = (f1dscb->ds1dsorg[0] << 8) | (f1dscb->ds1dsorg[1]); if (dsorg & (DSORG_IS * 256)) strcpy(txtdsorg, "IS"); if (dsorg & (DSORG_PS * 256)) strcpy(txtdsorg, "PS"); if (dsorg & (DSORG_DA * 256)) strcpy(txtdsorg, "DA"); if (dsorg & (DSORG_PO * 256)) strcpy(txtdsorg, "PO"); if (dsorg & DSORG_AM) strcpy(txtdsorg, "VS"); if (txtdsorg[0] == '\0') strcpy(txtdsorg, "??"); if (dsorg & (DSORG_U * 256)) strcat(txtdsorg, "U"); if (f1dscb->ds1recfm & RECFM_FORMAT_F) strcpy(txtrecfm, "F"); if (f1dscb->ds1recfm & RECFM_FORMAT_V) strcpy(txtrecfm, "V"); if ((f1dscb->ds1recfm & RECFM_FORMAT_U) == RECFM_FORMAT_U) strcpy(txtrecfm, "U"); if (f1dscb->ds1recfm & RECFM_BLOCKED) strcat(txtrecfm, "B"); if (f1dscb->ds1recfm & RECFM_SPANNED) strcat(txtrecfm, "S"); if (f1dscb->ds1recfm & RECFM_CTLCHAR_A) strcat(txtrecfm, "A"); if (f1dscb->ds1recfm & RECFM_CTLCHAR_M) strcat(txtrecfm, "M"); if (f1dscb->ds1recfm & RECFM_TRKOFLOW) strcat(txtrecfm, "T"); // Field ignored: ds1optcd (option codes, same as in DCB) blksize = (f1dscb->ds1blkl[0] << 8) | f1dscb->ds1blkl[1]; lrecl = (f1dscb->ds1lrecl[0] << 8) | f1dscb->ds1lrecl[1]; // Field ignored: ds1keyl (key length) // Field ignored: ds1rkp (relative key position) // Field ignored: ds1dsind (data set indicators) // Field ignored: ds1scalo (secondary allocation) // Field ignored: ds1lstar (pointer to last written block; ttr) // Field ignored: ds1trbal (bytes remaining on last track used) // Extent information was passed to us, so we ignore what's in F1DSCB fprintf(fmsg, "Dataset %s on volume %s sequence %d\n", dsn, volser, volseq); fprintf(fmsg, "Created %s expires %s\n", txtcredt, txtexpdt); fprintf(fmsg, "Dsorg=%s recfm=%s lrecl=%d blksize=%d\n", txtdsorg, txtrecfm, lrecl, blksize); fprintf(fmsg, "System code %s\n", txtsyscd); if (verbose > 1) { fprintf(stderr, "Dataset has %d extent(s)\n", num_extents); if (verbose > 2) data_dump((void *)extent, sizeof(extent) * MAX_EXTENTS); fprintf(stderr, "Extent Information:\n"); fprintf(stderr, " EXTENT --begin-- ---end---\n"); fprintf(stderr, "TYPE NUMBER CCCC HHHH CCCC HHHH\n"); for (i = 0; i < num_extents; i++) { int bcyl = (extent[i].xtbcyl[0] << 8) | extent[i].xtbcyl[1]; int btrk = (extent[i].xtbtrk[0] << 8) | extent[i].xtbtrk[1]; int ecyl = (extent[i].xtecyl[0] << 8) | extent[i].xtecyl[1]; int etrk = (extent[i].xtetrk[0] << 8) | extent[i].xtetrk[1]; fprintf(stderr, " %2.2X %2.2X %4.4X %4.4X %4.4X %4.4X\n", extent[i].xttype, extent[i].xtseqn, bcyl, btrk, ecyl, etrk); } } return; } /* showf1 */
int getF1dscb( CIFBLK *cif, char *pdsn[], FORMAT1_DSCB *f1dscb, DSXTENT *vtocext[], int verbose) { char zdsn[sizeof(f1dscb->ds1dsnam) + 1]; // zASCII dsn BYTE edsn[sizeof(f1dscb->ds1dsnam)]; // EBCDIC dsn void *f1key, *f1data; int f1kl, f1dl; int cyl, head, rec, rc; int vtocextents = 1; // VTOC has only one extent // Locate dataset's F1 DSCB memset(zdsn, 0, sizeof(zdsn)); strncpy(zdsn, *pdsn, sizeof(zdsn) - 1); string_to_upper(zdsn); convert_to_ebcdic(edsn, sizeof(edsn), zdsn); if (verbose) fprintf(stderr, "getF1dscb searching VTOC for %s\n", zdsn); rc = search_key_equal(cif, edsn, sizeof(edsn), vtocextents, (DSXTENT *)vtocext, &cyl, &head, &rec); if (rc) { fprintf(stderr, "getF1dscb search_key_equal rc %d\n", rc); if (verbose) { fprintf(stderr, "getF1dscb key\n"); data_dump(edsn, sizeof(edsn)); } if (rc == 1) fprintf(stderr, "getF1dscb no DSCB found for %s\n", zdsn); return 1; } // Read F1 DSCB describing dataset if (verbose) fprintf(stderr, "getF1dscb reading F1 DSCB\n"); rc = read_block(cif, cyl, head, rec, (void *)&f1key, &f1kl, (void *) &f1data, &f1dl); if (rc) { fprintf(stderr, "getF1dscb error reading F1 DSCB, rc %d\n", rc); return 2; } // Return data to caller if ((f1kl == sizeof(f1dscb->ds1dsnam)) && (f1dl == (sizeof(FORMAT1_DSCB) - sizeof(f1dscb->ds1dsnam)))) { memcpy((void *) &f1dscb->ds1dsnam, f1key, f1kl); // copy F1 key to buffer memcpy((void *) &f1dscb->ds1fmtid, f1data, f1dl); // copy F1 data to buffer } else { fprintf(stderr, "getF1dscb bad key %d or data length %d\n", f1kl, f1dl); return 3; } if (verbose > 1) { fprintf(stderr, "getF1dscb F1 DSCB\n"); data_dump((void *) f1dscb, sizeof(FORMAT1_DSCB)); } // Verify DS1FMTID byte = x'F1' // Do this after copying data to caller's buffer so we can use struct fields // rather than having to calculate offset to verified data; little harm done // if it doesn't verify since we're toast if it's bad. if (f1dscb->ds1fmtid != 0xf1) { fprintf(stderr, "getF1dscb " "F1 DSCB format id byte invalid (DS1IDFMT) %2.2X\n", f1dscb->ds1fmtid); return 4; } return 0; } /* getF1dscb */
int getF4dscb( CIFBLK *cif, FORMAT4_DSCB *f4dscb, DASD_VOL_LABEL *volrec, DSXTENT *vtocx, int verbose) { char vtockey[sizeof(f4dscb->ds4keyid)]; void *f4key, *f4data; int f4kl, f4dl; int cyl, head, rec, rc; // Extract VTOC's CCHHR from volume label cyl = (volrec->volvtoc[0] << 8) | volrec->volvtoc[1]; head = (volrec->volvtoc[2] << 8) | volrec->volvtoc[3]; rec = volrec->volvtoc[4]; if (verbose > 1) fprintf(stderr, "getF4dscb VTOC F4 at cyl %d head %d rec %d\n", cyl, head, rec); // Read VTOC's Format 4 DSCB (VTOC self-descriptor) if (verbose) fprintf(stderr, "getF4dscb reading VTOC F4 DSCB\n"); rc = read_block(cif, cyl, head, rec, (void *) &f4key, &f4kl, (void *) &f4data, &f4dl); if (rc) { fprintf(stderr, "getF4dscb error reading F4 DSCB, rc %d\n", rc); return 1; } // Verify correct key and data length if ((f4kl != sizeof(f4dscb->ds4keyid)) || (f4dl != (sizeof(FORMAT4_DSCB) - sizeof(f4dscb->ds4keyid)))) { fprintf(stderr, "getF4dscb erroneous key length %d or data length %d\n", f4kl, f4dl); return 2; } // Return data to caller memcpy((void *) &f4dscb->ds4keyid, f4key, f4kl); // copy F4 key into buffer memcpy((void *) &f4dscb->ds4fmtid, f4data, f4dl); // copy F4 data into buffer memcpy((void *) vtocx, (void *)&f4dscb->ds4vtoce, sizeof(f4dscb->ds4vtoce)); // copy VTOC extent entry if (verbose > 1) { fprintf(stderr, "getF4dscb F4 DSCB\n"); data_dump((void *) f4dscb, sizeof(FORMAT4_DSCB)); } // Verify DS4FMTID byte = x'F4', DS4KEYID key = x'04', and DS4NOEXT = x'01' // Do this after copying data to caller's buffer so we can use struct fields // rather than having to calculate offset to verified data; little harm done // if it doesn't verify since we're toast if they're bad. memset(vtockey, 0x04, sizeof(vtockey)); if ((f4dscb->ds4fmtid != 0xf4) || (f4dscb->ds4noext != 0x01) || (memcmp(&f4dscb->ds4keyid, vtockey, sizeof(vtockey)))) { fprintf(stderr, "getF4dscb " "VTOC format id byte invalid (DS4IDFMT) %2.2X, \n" "VTOC key invalid, or multi-extent VTOC\n", f4dscb->ds4fmtid); return 3; } // Display VTOC extent info (always one extent, never more) if (verbose > 1) { fprintf (stderr, "getF4dscb " "VTOC start CCHH=%2.2X%2.2X %2.2X%2.2X " "end CCHH=%2.2X%2.2X %2.2X%2.2X\n", vtocx->xtbcyl[0], vtocx->xtbcyl[1], vtocx->xtbtrk[0], vtocx->xtbtrk[1], vtocx->xtecyl[0], vtocx->xtecyl[1], vtocx->xtetrk[0], vtocx->xtetrk[1]); } return 0; } /* getF4dscb */
/* Dump a TCP segment header. Assumed to be in network byte order */ void tcp_dump(unsigned char *data, int length, int hexdump) { int source, dest; int seq; int ack; int flags; int wnd; int up; int hdrlen; int mss = 0; source = get16(data + 0); dest = get16(data + 2); seq = get32(data + 4); ack = get32(data + 8); hdrlen = (data[12] & 0xF0) >> 2; flags = data[13]; wnd = get16(data + 14); up = get16(data + 18); lprintf(T_PROTOCOL, "TCP:"); lprintf(T_TCPHDR, " %s->", servname(source, "tcp")); lprintf(T_TCPHDR, "%s Seq x%x", servname(dest, "tcp"), seq); if (flags & ACK) lprintf(T_TCPHDR, " Ack x%x", ack); if (flags & CE) lprintf(T_TCPHDR, " CE"); if (flags & URG) lprintf(T_TCPHDR, " URG"); if (flags & ACK) lprintf(T_TCPHDR, " ACK"); if (flags & PSH) lprintf(T_TCPHDR, " PSH"); if (flags & RST) lprintf(T_TCPHDR, " RST"); if (flags & SYN) lprintf(T_TCPHDR, " SYN"); if (flags & FIN) lprintf(T_TCPHDR, " FIN"); lprintf(T_TCPHDR, " Wnd %d", wnd); if (flags & URG) lprintf(T_TCPHDR, " UP x%x", up); /* Process options, if any */ if (hdrlen > TCPLEN && length >= hdrlen) { unsigned char *cp = data + TCPLEN; int i = hdrlen - TCPLEN; int kind, optlen; while (i > 0) { kind = *cp++; /* Process single-byte options */ switch (kind) { case EOL_KIND: i--; cp++; break; case NOOP_KIND: i--; cp++; continue; } /* All other options have a length field */ optlen = *cp++; /* Process valid multi-byte options */ switch (kind) { case MSS_KIND: if (optlen == MSS_LENGTH) mss = get16(cp); break; } optlen = max(2, optlen); /* Enforce legal minimum */ i -= optlen; cp += optlen - 2; } } if (mss != 0) lprintf(T_TCPHDR," MSS %d", mss); length -= hdrlen; data += hdrlen; if (length > 0) { lprintf(T_TCPHDR, " Data %d\n", length); data_dump(data, length, hexdump); return; } lprintf(T_TCPHDR, "\n"); }
/*-------------------------------------------------------------------*/ int main (int argc, char *argv[]) { char *pgmname; /* prog name in host format */ char *pgm; /* less any extension (.ext) */ char msgbuf[512]; /* message build work area */ int cckd_diag_rc = 0; /* Program return code */ char *fn; /* File name */ CKDDASD_DEVHDR devhdr; /* [C]CKD device hdr */ CCKDDASD_DEVHDR cdevhdr; /* Compressed CKD device hdr */ CKDDEV *ckd=0; /* CKD DASD table entry */ FBADEV *fba=0; /* FBA DASD table entry */ int cmd_devhdr = 0; /* display DEVHDR */ int cmd_cdevhdr = 0; /* display CDEVHDR */ int cmd_l1tab = 0; /* display L1TAB */ int cmd_l2tab = 0; /* display L2TAB */ int cmd_trkdata = 0; /* display track data */ int cmd_hexdump = 0; /* display track data (hex) */ int cmd_offset = 0; /* 1 = display data at */ int op_offset = 0; /* op_offset of length */ int op_length = 0; /* op_length */ int cmd_cchh = 0; /* 1 = display CCHH data */ int op_cc = 0; /* CC = cylinder */ int op_hh = 0; /* HH = head */ int cmd_tt = 0; /* 1 = display TT data */ int op_tt = 0; /* relative track # */ int swapend; /* 1 = New endianess doesn't match machine endianess */ int n, trk=0, l1ndx=0, l2ndx=0; off_t l2taboff=0; /* offset to assoc. L2 table */ int ckddasd; /* 1=CKD dasd 0=FBA dasd */ int heads=0; /* Heads per cylinder */ off_t trkhdroff=0; /* offset to assoc. trk hdr */ int imglen=0; /* track length */ char pathname[MAX_PATH]; /* file path in host format */ char *strtok_str = NULL; /* Set program name */ if ( argc > 0 ) { if ( strlen(argv[0]) == 0 ) { pgmname = strdup( UTILITY_NAME ); } else { char path[MAX_PATH]; #if defined( _MSVC_ ) GetModuleFileName( NULL, path, MAX_PATH ); #else strncpy( path, argv[0], sizeof( path ) ); #endif pgmname = strdup(basename(path)); #if !defined( _MSVC_ ) strncpy( path, argv[0], sizeof(path) ); #endif } } else { pgmname = strdup( UTILITY_NAME ); } pgm = strtok_r( strdup(pgmname), ".", &strtok_str); INITIALIZE_UTILITY( pgmname ); /* Display the program identification message */ MSGBUF( msgbuf, MSG_C( HHC02499, "I", pgm, "CCKD diagnostic program" ) ); display_version (stderr, msgbuf+10, FALSE); /* parse the arguments */ argc--; argv++ ; while (argc > 0) { if(**argv != '-') break; switch(argv[0][1]) { case 'v': if (argv[0][2] != '\0') return syntax (pgm); return 0; case 'd': if (argv[0][2] != '\0') return syntax (pgm); cmd_devhdr = 1; break; case 'c': if (argv[0][2] != '\0') return syntax (pgm); cmd_cdevhdr = 1; break; case '1': if (argv[0][2] != '\0') return syntax (pgm); cmd_l1tab = 1; break; case '2': if (argv[0][2] != '\0') return syntax (pgm); cmd_l2tab = 1; break; case 'a': if (argv[0][2] != '\0') return syntax (pgm); cmd_cchh = 1; argc--; argv++; op_cc = offtify(*argv); argc--; argv++; op_hh = offtify(*argv); break; case 'r': if (argv[0][2] != '\0') return syntax (pgm); cmd_tt = 1; argc--; argv++; op_tt = offtify(*argv); break; case 'o': if (argv[0][2] != '\0') return syntax (pgm); cmd_offset = 1; argc--; argv++; op_offset = offtify(*argv); argc--; argv++; op_length = offtify(*argv); break; case 't': if (argv[0][2] != '\0') return syntax (pgm); cmd_trkdata = 1; break; case 'x': if (argv[0][2] != '\0') return syntax (pgm); cmd_hexdump = 1; cmd_trkdata = 1; break; case 'g': if (argv[0][2] != '\0') return syntax (pgm); debug = 1; break; default: return syntax (pgm); } argc--; argv++; } if (argc != 1) return syntax (pgm); fn = argv[0]; /* open the file */ hostpath(pathname, fn, sizeof(pathname)); fd = HOPEN(pathname, O_RDONLY | O_BINARY); if (fd < 0) { fprintf(stderr, _("cckddiag: error opening file %s: %s\n"), fn, strerror(errno)); return -1; } /*---------------------------------------------------------------*/ /* display DEVHDR - first 512 bytes of dasd image */ /*---------------------------------------------------------------*/ readpos(fd, &devhdr, 0, sizeof(devhdr)); if (cmd_devhdr) { fprintf(stderr, "\nDEVHDR - %d (decimal) bytes:\n", (int)sizeof(devhdr)); data_dump(&devhdr, sizeof(devhdr)); } /*---------------------------------------------------------------*/ /* Determine CKD or FBA device type */ /*---------------------------------------------------------------*/ if (memcmp(devhdr.devid, "CKD_C370", 8) == 0 || memcmp(devhdr.devid, "CKD_S370", 8) == 0) { ckddasd = 1; ckd = dasd_lookup(DASD_CKDDEV, NULL, devhdr.devtype, 0); if (ckd == NULL) { fprintf(stderr, "DASD table entry not found for devtype 0x%2.2X\n", devhdr.devtype); clean(); exit(5); } } else if (memcmp(devhdr.devid, "FBA_C370", 8) == 0 || memcmp(devhdr.devid, "FBA_S370", 8) == 0) { ckddasd = 0; fba = dasd_lookup(DASD_FBADEV, NULL, devhdr.devtype, 0); if (fba == NULL) { fprintf(stderr, "DASD table entry not found for " "devtype 0x%2.2X\n", DEFAULT_FBA_TYPE); clean(); exit(6); } } else { fprintf(stderr, "incorrect header id\n"); clean(); return -1; } /*---------------------------------------------------------------*/ /* Set up device characteristics */ /*---------------------------------------------------------------*/ if (ckddasd) { heads = ((U32)(devhdr.heads[3]) << 24) | ((U32)(devhdr.heads[2]) << 16) | ((U32)(devhdr.heads[1]) << 8) | (U32)(devhdr.heads[0]); if (debug) fprintf(stderr, "\nHHC90000D DBG: %s device has %d heads/cylinder\n", ckd->name, heads); } /*---------------------------------------------------------------*/ /* display CDEVHDR - follows DEVHDR */ /*---------------------------------------------------------------*/ readpos(fd, &cdevhdr, CKDDASD_DEVHDR_SIZE, sizeof(cdevhdr)); if (cmd_cdevhdr) { fprintf(stderr, "\nCDEVHDR - %d (decimal) bytes:\n", (int)sizeof(cdevhdr)); data_dump(&cdevhdr, sizeof(cdevhdr)); } /*---------------------------------------------------------------*/ /* Find machine endian-ness */ /*---------------------------------------------------------------*/ /* cckd_endian() returns 1 for big-endian machines */ swapend = (cckd_endian() != ((cdevhdr.options & CCKD_BIGENDIAN) != 0)); /*---------------------------------------------------------------*/ /* display L1TAB - follows CDEVHDR */ /*---------------------------------------------------------------*/ /* swap numl1tab if needed */ n = cdevhdr.numl1tab; if (swapend) cckd_swapend4((char *)&n); l1 = makbuf(n * CCKD_L1ENT_SIZE, "L1TAB"); readpos(fd, l1, CCKD_L1TAB_POS, n * CCKD_L1ENT_SIZE); /* L1TAB itself is not adjusted for endian-ness */ if (cmd_l1tab) { fprintf(stderr, "\nL1TAB - %d (0x%X) bytes:\n", (int)(n * CCKD_L1ENT_SIZE), (unsigned int)(n * CCKD_L1ENT_SIZE)); data_dump(l1, n * CCKD_L1ENT_SIZE); } /*---------------------------------------------------------------*/ /* display OFFSET, LENGTH data */ /*---------------------------------------------------------------*/ if (cmd_offset) { bulk = makbuf(op_length, "BULK"); readpos(fd, bulk, op_offset, op_length); fprintf(stderr, "\nIMAGE OFFSET %d (0x%8.8X) " "of length %d (0x%8.8X) bytes:\n", op_offset, op_offset, op_length, op_length); data_dump(bulk, op_length); free(bulk); bulk = NULL; } /*---------------------------------------------------------------*/ /* FBA isn't supported here because I don't know much about FBA */ /*---------------------------------------------------------------*/ if ( (!ckddasd) && ((cmd_cchh) || (cmd_tt)) ) { fprintf(stderr, "CCHH/reltrk not supported for FBA\n"); clean(); exit(3); } /*---------------------------------------------------------------*/ /* Setup CCHH or relative track request */ /*---------------------------------------------------------------*/ if (ckddasd) { if (cmd_tt) { trk = op_tt; op_cc = trk / heads; op_hh = trk % heads; } else { trk = (op_cc * heads) + op_hh; } l1ndx = trk / cdevhdr.numl2tab; l2ndx = trk % cdevhdr.numl2tab; l2taboff = l1[l1ndx]; if (swapend) cckd_swapend4((char *)&l2taboff); } /*---------------------------------------------------------------*/ /* display CKD CCHH or relative track data */ /*---------------------------------------------------------------*/ if ((cmd_cchh) || (cmd_tt)) { fprintf(stderr, "CC %d HH %d = reltrk %d; " "L1 index = %d, L2 index = %d\n" "L1 index %d = L2TAB offset %d (0x%8.8X)\n", op_cc, op_hh, trk, l1ndx, l2ndx, l1ndx, (int)l2taboff, (int)l2taboff); l2 = makbuf(cdevhdr.numl2tab * sizeof(CCKD_L2ENT), "L2TAB"); readpos(fd, l2, l2taboff, cdevhdr.numl2tab * sizeof(CCKD_L2ENT)); if (cmd_l2tab) { fprintf(stderr, "\nL2TAB - %d (decimal) bytes\n", (int)(cdevhdr.numl2tab * sizeof(CCKD_L2ENT))); data_dump(l2, (cdevhdr.numl2tab * sizeof(CCKD_L2ENT)) ); } fprintf(stderr, "\nL2 index %d = L2TAB entry %d bytes\n", l2ndx, (int)sizeof(CCKD_L2ENT) ); data_dump(&l2[l2ndx], sizeof(CCKD_L2ENT) ); trkhdroff = l2[l2ndx].pos; imglen = l2[l2ndx].len; if (swapend) { cckd_swapend4((char *)&trkhdroff); cckd_swapend4((char *)&imglen); } fprintf(stderr, "\nTRKHDR offset %d (0x%8.8X); " "length %d (0x%4.4X)\n", (int)trkhdroff, (int)trkhdroff, imglen, imglen); tbuf = makbuf(imglen, "TRKHDR+DATA"); readpos(fd, tbuf, trkhdroff, imglen); fprintf(stderr, "\nTRKHDR track %d\n", trk); data_dump(tbuf, sizeof(CKDDASD_TRKHDR) ); if (cmd_trkdata) showtrk(tbuf, imglen, trk, cmd_hexdump); free(l2); free(tbuf); l2 = NULL; tbuf = NULL; } /* Close file, exit */ fprintf(stderr, "\n"); clean(); return cckd_diag_rc; }
int main(int argc, char **argv) { DADSM dadsm; // DADSM workarea FILE *fout = NULL; // output file CIFBLK *cif; int dsn_recs_written = 0, bail, dsorg, rc; char pathname[MAX_PATH]; fprintf(stderr, "dasdseq %s (C) Copyright 1999-2010 Roger Bowler\n" "Portions (C) Copyright 2001-2010 James M. Morrison\n", VERSION); if (debug) fprintf(stderr, "DEBUG enabled\n"); // Parse command line memset(&dadsm, 0, sizeof(dadsm)); // init DADSM workarea rc = parsecmd(argc, argv, &dadsm); if (rc) exit(rc); // Open CKD image cif = open_ckd_image(din, sfn, O_RDONLY | O_BINARY, 0); if (!cif) { fprintf(stderr, "dasdseq unable to open image file %s\n", din); exit(20); } // Unless -abs specified (in which case trust the expert user): // Retrieve extent information for the dataset // Display dataset attributes // Verify dataset has acceptable attributes if (!absvalid) { rc = dadsm_setup(cif, &argdsn, &dadsm, local_verbose); if (rc) { close_ckd_image(cif); exit(rc); } if (local_verbose) { fprintf(stderr, "\n"); showf1(stderr, &dadsm.f1buf, dadsm.f1ext, copy_verbose); fprintf(stderr, "\n"); } bail = 1; dsorg = (dadsm.f1buf.ds1dsorg[0] << 8) | (dadsm.f1buf.ds1dsorg[1]); if (dsorg & (DSORG_PS * 256)) { if ((dadsm.f1buf.ds1recfm & RECFM_FORMAT) == RECFM_FORMAT_F) bail = 0; if ((dadsm.f1buf.ds1recfm & RECFM_FORMAT) == RECFM_FORMAT_V) { bail = 1; // not yet fprintf(stderr, "dasdseq only supports RECFM=F[B]\n"); } } else fprintf(stderr, "dasdseq only supports DSORG=PS datasets\n"); if (bail) { close_ckd_image(cif); exit(21); } } // Open output dataset (EBCDIC requires binary open) hostpath(pathname, argdsn, sizeof(pathname)); fout = fopen(pathname, (tran_ascii) ? "wb" : "w"); if (fout == NULL) { fprintf(stderr, "dasdseq unable to open output file %s, %s\n", argdsn, strerror(errno)); close_ckd_image(cif); exit(22); } if (local_verbose) fprintf(stderr, "dasdseq writing %s\n", argdsn); // Write dasd data to output dataset dsn_recs_written = fbcopy(fout, cif, &dadsm, tran_ascii, copy_verbose); if (dsn_recs_written == -1) fprintf(stderr, "dasdseq error processing %s\n", argdsn); else fprintf(stderr, "dasdseq wrote %d records to %s\n", dsn_recs_written, argdsn); // Close output dataset, dasd image and return to caller fclose(fout); if (local_verbose > 2) fprintf(stderr, "CLOSED %s\n", argdsn); if (local_verbose > 3) { fprintf(stderr, "CIFBLK\n"); data_dump((void *) cif, sizeof(CIFBLK)); } close_ckd_image(cif); if (local_verbose > 2) fprintf(stderr, "CLOSED image\n"); return rc; } /* main */
int parsecmd(int argc, char **argv, DADSM *dadsm) { int util_verbose = 0; // Hercules dasdutil.c diagnostic level int heads = 15; // # heads per cylinder on device int extnum = 0; // extent number for makext() int abscyl = 0; // absolute CC (default 0) int abshead = 0; // absolute HH (default 0) int abstrk = 1; // absolute tracks (default 1) int lrecl = 80; // default F1 DSCB lrecl // Usage: dasdseq [-debug] [-expert] [-ascii] image [sf=shadow] [attr] filespec argv++; // skip dasdseq command argv[0] if ((*argv) && (strcasecmp(*argv, "-debug") == 0)) { argv++; debug = 1; fprintf(stderr, "Command line DEBUG specified\n"); } if ((*argv) && (strcasecmp(*argv, "-expert") == 0)) { argv++; expert = 1; if (debug) fprintf(stderr, "EXPERT mode\n"); } if ((*argv) && (strcasecmp(*argv, "-ascii") == 0)) { argv++; tran_ascii = 1; if (debug) fprintf(stderr, "ASCII translation enabled\n"); } if (*argv) din = *argv++; // dasd image filename if (debug) fprintf(stderr, "IMAGE %s\n", din); if (*argv && strlen(*argv) > 3 && !memcmp(*argv, "sf=", 3)) { sfn = *argv++; // shadow file parm } else sfn = NULL; if (debug) fprintf(stderr, "SHADOW %s\n", sfn); dadsm->f1buf.ds1recfm = RECFM_FORMAT_F | RECFM_BLOCKED; // recfm FB for fbcopy if ((*argv) && (strcasecmp(*argv, "-recfm") == 0)) { argv++; // skip -recfm if ((*argv) && (strcasecmp(*argv, "fb") == 0)) { argv++; // skip fb if (debug) fprintf(stderr, "RECFM fb\n"); } else { argv++; // skip bad recfm fprintf(stderr, "Unsupported -recfm value %s\n", *argv); } } if ((*argv) && (strcasecmp(*argv, "-lrecl") == 0)) { argv++; // skip -lrecl if (*argv) lrecl = atoi(*argv++); // lrecl value if (debug) fprintf(stderr, "LRECL %d\n", lrecl); } dadsm->f1buf.ds1lrecl[0] = lrecl >> 8; // for fbcopy dadsm->f1buf.ds1lrecl[1] = lrecl - ((lrecl >> 8) << 8); if ((*argv) && (strcasecmp(*argv, "-heads") == 0)) { argv++; // skip -heads if (*argv) heads = atoi(*argv++); // heads value } if (debug) fprintf(stderr, "HEADS %d\n", heads); if ((*argv) && (strcasecmp(*argv, "-abs") == 0)) { absvalid = 1; // CCHH valid while ((*argv) && (strcasecmp(*argv, "-abs") == 0)) { argv++; // skip -abs abscyl = 0; abshead = 0; abstrk = 1; // defaults if (*argv) abscyl = atoi(*argv++); // abs cc if (*argv) abshead = atoi(*argv++); // abs hh if (*argv) abstrk = atoi(*argv++); // abs tracks // Build extent entry for -abs group makext(extnum, heads, (DSXTENT *) &dadsm->f1ext, abscyl, abshead, abstrk); extnum++; dadsm->f1buf.ds1noepv = extnum; // for fbcopy if (debug) fprintf(stderr, "Absolute CC %d HH %d tracks %d\n", abscyl, abshead, abstrk); if (extnum > MAX_EXTENTS) { fprintf(stderr, "Too many extents, abort\n"); exit(3); } } // if (debug) sayext(MAX_EXTENTS, dadsm->f1ext);// show extent table } if (debug) { fprintf(stderr, "parsecmd completed F1 DSCB\n"); data_dump(&dadsm->f1buf, sizeof(FORMAT1_DSCB)); } if (*argv) argdsn = *argv++; // [MVS dataset name/]output filename if (debug) fprintf(stderr, "DSN %s\n", argdsn); if ((*argv) && ( // support deprecated 'ascii' operand (strcasecmp(*argv, "ascii") == 0) || (strcasecmp(*argv, "-ascii") == 0) ) ) { argv++; tran_ascii = 1; if (debug) fprintf(stderr, "ASCII translation enabled\n"); } set_verbose_util(0); // default util verbosity if ((*argv) && (strcasecmp(*argv, "verbose") == 0)) { local_verbose = 1; argv++; if (*argv) local_verbose = atoi(*argv++); if (*argv) copy_verbose = atoi(*argv++); if (*argv) { util_verbose = atoi(*argv++); set_verbose_util(util_verbose); if (debug) fprintf(stderr, "Utility verbose %d\n", util_verbose); } } // If the user specified expert mode without -abs, give help & exit // Additionally, if the user has "extra" parms, show help & exit // No "extraneous parms" message is issued, since some of the code // above forces *argv to be true when it wants help displayed if ((argc < 3) || (*argv) || ((expert) && (!absvalid))) { showhelp(); // show syntax before bailing exit(2); } return 0; } /* parsecmd */
int command(int argc,char **argv) { if(argc<2) { printf("You must enter a command!\n"); return 1; } else { //Handling drive aquisition if(strcmp(argv[1],"-dd")==0) { if(argc<3) { printf("You must enter a source for the drive dump\n"); return 1; } else { if(argc<4) { printf("You must enter a destination for the drive dump\n"); return 1; } else { if(strcmp(argv[3],"/")==0) { printf("You have assigned %s as your destination, this is very dangerous....do you want to proceed?:(y,n) ",argv[3]); char t=getchar(); if(t=='y') { if(argc>5) { data_dump(argv[2],argv[3],drive_bsize); return 0; } else { data_dump(argv[2],argv[3],argv[4]); return 0; } } else return 0; } if(argc<5) data_dump(argv[2],argv[3],drive_bsize); else data_dump(argv[2],argv[3],argv[4]); } } } //Sparse raw unallocated recovery else if(strcmp(argv[1],"-Rsau")==0) { if(argc<3) { printf("You must specify an image\n"); return 1; } else if(argc<4) { printf("You must specify a keyword\n"); return 1; } else { sparse_accurate_unalloc(argv[2],argv[3]); } } //Handling help printing else if(strcmp(argv[1],"-h")==0 || strcmp(argv[1],"--help")==0) { help(); return 0; } //Validating files else if(strcmp(argv[1],"-v")==0) { if(argc<3) { printf("You must enter a filename\n"); return 1; } else if(argc<4) { printf("You must enter a second filename\n"); return 1; } else { checksum(argv[2],argv[3]); return 0; } } //Handleing mounting the file systems read only. else if(strcmp(argv[1],"-mr")==0) { if(argc<3) { printf("You must enter a filesystem or device to mount\n"); return 1; } else if(argc<4) { printf("You must specify a mount point\n"); return 1; } else mount(argv[2],argv[3],1); } //Handling mounting the filesystem with write support else if(strcmp(argv[1],"-m")==0) { if(argc<3) { printf("You must enter a filesystem or device to mount\n"); return 1; } else if(argc<4) { printf("You must specify a mount point\n"); return 1; } else mount(argv[2],argv[3],0); } //ascii block searching(nothing else) else if(strcmp(argv[1],"-sb")==0) { if(argc<3) { printf("You must enter a filename\n"); return 1; } else if(argc<4) { printf("You must enter a search string\n"); return 1; } else ascii_block_search(argv[3],argv[2]); } //Handling controlled dumps else if(strcmp(argv[1],"-cd")==0) { if(argc<3) { printf("You must enter a source file\n"); return 1; } else if(argc<4) { printf("You must enter a destination file\n"); return 1; } else if(argc<5) { printf("You must enter a starting point in bytes\n"); return 1; } else if(argc<6) { printf("You must enter an amount of times to collect the data\n"); return 1; } else if(argc<7) { controlled_dump(argv[2],argv[3],drive_bsize,argv[5],argv[4]); return 0; } else { controlled_dump(argv[2],argv[3],argv[6],argv[5],argv[4]); return 0; } } //Spare search of unallocated space else if(strcmp(argv[1],"-Rsu")==0) { if(argc<3) { printf("You must specify an image or source\n"); return 1; } else if(argc<4) { printf("You must enter a searchword\n"); return 1; } else { sparse_unalloc(argv[2],argv[3]); return 0; } } //Recover all unallocated files else if(strcmp(argv[1],"-Ru")==0) { if(argc<3) { printf("You must specify an image or source\n"); return 1; } else { all_unalloc(argv[2]); return 0; } } //Accurate recovery of all files in unallocated space else if(strcmp(argv[1],"-Rau")==0) { if(argc<3) { printf("You must specify an image or source\n"); return 1; } else { accurate_all_unalloc(argv[2]); return 0; } } //Search for a specific filename in an image else if(strcmp(argv[1],"-s")==0) { if(argc<3) { printf("You must enter a source file\n"); return 1; } else if(argc<4) { printf("You must enter a file to search for\n"); return 1; } else { search_all(argv[2],argv[3]); return 0; } } //Listing all files in an image else if(strcmp(argv[1],"-l")==0) { if(argc<3) { printf("Enter a filesystem to scan\n"); return 1; } else { list_all(argv[2]); return 0; } } //Sparse search else if(strcmp(argv[1],"-Rs")==0) { if(argc<3) { printf("You must specify an image\n"); return 1; } else if(argc<4) { printf("You must specify a keyword\n"); return 1; } else { sparse_all(argv[2],argv[3]); return 0; } } //Get all files in tact else if(strcmp(argv[1],"-R")==0) { if(argc<3) { printf("You must specify an image\n"); return 1; } else { get_everything(argv[2]); return 0; } } else if(strcmp(argv[1],"-Ra")==0) { if(argc<3) { printf("You must specify an image\n"); } else { accurate_all(argv[2]); return 0; } } //Recover a specific inode else if(strcmp(argv[1],"-Ri")==0) { if(argc<3) { printf("You must specify an image\n"); return 1; } else if(argc<4) { printf("You must enter an inode\n"); return 1; } else { accurate_recover_inode(argv[2],argv[3]); return 0; } } //Else else { printf("You have entered giberish, please attend to your errors\n"); return 0; } } }