Início / unix / Perguntas / 528208
Accepted
Andriy Makukha
Asked: 2019-07-04 05:22:27 +0800 CST

Undump od (despejo octal ou hexadecimal) na versão 6 Unix

  • 772

odO comando (octal dump) é implementado no Unix desde a versão 1. No entanto, não consegui encontrar um comando reverso no manual do Unix da versão 6 (1975). Maneiras modernas de reverter odcom xxdou sednão se aplicam ao Unix V6, uma vez que sede awkapareceu apenas na versão 7 (enquanto uudecode, xxde base64não estão disponíveis também).

As perguntas são:

  • Como as pessoas em 1975 converteram listagens octais ou hexadecimais em arquivos binários?
  • Como posso fazer isso em um emulador PDP-11 que só me permite colar texto no terminal da área de transferência? (Em outras palavras, é necessário escrever meu próprio programa para isso?)

Aqui está um exemplo de despejo hexadecimal de um arquivo binário odque eu gostaria de converter de volta em binário:

# od -h /bin/sum
0000000 0107 00ba 0000 0204 0000 0000 0000 0001
0000020 1583 0bd6 0ac3 0601 8901 0a37 00ae 15b7
0000040 0002 8905 0000 0000 8609 15c0 0001 8904
0000060 0026 0005 01ef 706f 6472 000a 1001 0a05
0000100 1040 8903 00be 0200 870b 0bc0 030e 0ab7
0000120 007a 15c2 00be 9484 6105 0b45 7e04 01f0
0000140 15c0 0001 8904 0080 0002 09f7 0026 15c0
0000160 0001 8904 0083 0001 1dc5 0050 09f7 0014
0000200 15c0 0001 8904 0082 0001 1040 8906 01c2
0000220 203f 200a 1026 1066 1141 09f7 0006 1581
0000240 1580 0087 0a00 7217 000a 1066 1001 0302
0000260 09f7 fff0 15b7 0012 65f7 0030 000c 15c0
0000300 0001 8904 00ba 0001 0087
0000312
od hex

2 respostas

  1. Best Answer

    Parece que a versão 6 do Unix ainda não incluiu muitas ferramentas comuns que apareceram apenas na versão 7 (como sede awk). Nesse ponto, o Unix também não foi comercializado ainda, então "reverse hex dump" poderia estar faltando simplesmente porque não havia uma grande demanda por essa operação ou porque Ken (ou algum outro programador) forneceu tal ferramenta de seu /usrdiretório não oficial no Bell Labs. Quem sabe.

    Mas aqui está minha implementação para reverter um dump hexadecimal no Unix V6. Quando compilado como cc -s -O unhex.c, o executável resultante tem apenas 1160 bytes e funciona mais rápido que o dumping (como esperado).

    Observe como a linguagem C daquela época ainda tinha sintaxe de atribuição composta de B ( =+, =*, etc.) e como esperava que os programadores fornecessem seus próprios buffers para E/S de arquivo.

    /* reverse "od -h" operation on Unix V6 */
/* written in pre-K&R C */
/* derived from wc.c and cvopt.c */

int ibuf[259];
int obuf[259];

main(argc,argv)
char **argv;
{
    int token, bytecnt;
    register char *p1, *p2;         /* input buffer pointers */
    register int c;                 /* char or read count */
    char sp, b1, b2, lastc, lastb2, nfirst;

    obuf[0] = 1;                    /* standard output by default */
    if (argc>2) {
                                    /* create output file */
            if ((obuf[0] = creat(argv[2], 0666)) < 0) {
                    diag(argv[2]);
                    diag(": failed to create\n");
                    return;
            }
    }
    if (argc>1 && fopen(argv[1], ibuf)>=0) {
            p1 = 0;
            p2 = 0;
            sp = 0;
            token = 0;
            bytecnt = 0;
            nfirst = 0;
            for(;;) {
                    /* reading from file */
                    if (p1 >= p2) {
                            p1 = &ibuf[1];
                            c = read(ibuf[0], p1, 512);
                            if (c <= 0)
                                    break;
                            p2 = p1+c;
                    }
                    /* decoding loop */
                    c = 0;
                    c =| *p1++;
                    if (c==' ' || c=='\n') {
                            b1 = token;
                            b2 = token >> 8;
                            if (lastc!=' ' && lastc!='\n') {
                                    /* end of token */
                                    if (sp>0) {
                                            if (nfirst) putc(lastb2, obuf);
                                            putc(b1, obuf);
                                            lastb2 = b2;
                                            nfirst = 1;
                                    } else {
                                            /* first token in the line */
                                            bytecnt = token;
                                    }
                            }
                            if (c==' ') sp++;
                            else {
                                    /* new line */
                                    sp = 0;
                                    fflush(obuf);
                            }
                            token = 0;
                    } else {
                            /* actual hex and octal conversion */
                            token =* sp>0 ? 16 : 8;
                            token =+ c<='9' ? c-'0' : c-'W';
                    }
                    lastc = c;
            }
            if (!(bytecnt & 1)) {
                    putc(lastb2, obuf);
                    fflush(obuf);
            }
            close(ibuf[0]);
            close(obuf[0]);
    } else if (argc>1) {
            diag(argv[1]);
            diag(": cannot open\n");
    } else {
            diag("error: filename missing\n");
    }
}

diag(s)
char *s;
{
    while(*s)
            write(2,s++,1);
}

    UPD. Publiquei uma versão mais rápida e simples no GitHub , onde a sintaxe também é destacada.

    • 3

  2. Aqui está um programa C mínimo que você pode tentar compilar no V6 Unix.

    #define EOF (-1)
int main(){
  int i,a,b;
  while(scanf("%*7o") != EOF){
    for(i = 0; i<8; i++)
      if(scanf("%2x%2x",&a,&b) != EOF){putchar(a); putchar(b);}
  }
}

    Se o resultado acabar com a troca de bytes, pode ser necessário inverter os 2 putchars.

    • 2

relate perguntas