From: k.gehrke@bamp.berlinet.in-berlin.de (Kay Gehrke)
Newsgroups: de.comp.sys.amiga.misc
Subject: Hilfe Z-Connect
Organization: BAMP Public Mailbox in Berlin , Germany
Date: Mon, 25 Jan 1993 20:51:00 +0100

Halloechen,mal weitergeleitet fuer einen Kumpel,wer helfen kann,
bitte an mich per PM schreiben.....

Kay

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Halloechen...

Sooo, ich habe mal ein etwas anspruchsvolleres Problem - ich habe einfach
keinen Durchblick. Es geht um das ZCONNECT-Format, ich denke davon hat
jeder schon gehoert, der sich etwas in den Netzen rumtreibt. Nun habe ich
hier das Manual und stosse auf viiiel Arbeit. Bis ich das alles
zufriedenstellend implementiert habe vergeht noch so einige Zeit. Aber
zunaechst muss ich mir darueber klar werden, ob ich ein paar Sachen ueberhaupt
realisieren kann ohne zum C-Compiler zu greifen, ich fang einfach mal an :

------------------------ SCHNIPP -------------------------
ZCONNECT implementieren

Aber auch  wenn Sie  nicht in  "C" arbeiten,  werden Sie mit wenig
Aufwand die  Uebertragungsphase realisieren  koennen. Sie  benoetigen
dazu:

    -    Eine 16-bit CRC Routine nach dem X-MODEM Polynom,
------------------------ SCHNAPP -------------------------
Ahja, klingt doch gut, da ich nicht in "C" arbeite, muesste es mir ja auch
irgendwie moeglich sein.
------------------------ SCHNIPP -------------------------

Header duerfen  mehrfach in  einem Block  auftreten  (also  mehrere
Zeilen mit derselben Kennung), wenn das sinnvoll ist.

Ueber jeden Block wird eine Pruefsumme auf Basis eines 16-Bit
CRC nach  X-MODEM Polynom errechnet. Diese Pruefsumme wird dann im
Block selber  mitgesendet. Dies  geschieht auf einer Zeile mit der
Kennung   "CRC".   Die   Pruefsumme   wird   in   grossgeschriebenen
Hexadezimalzahlen (vierstellig  mit fuehrenden  Nullen)  angegeben.
Diese Zeile  sowie alle "\r" gehen nicht mit in die Pruefsumme ein.
Der CRC  muss daher  nicht an  einer bestimmten  Position in  Block
stehen. Der  CRC muss  auch bei gesicherten Verbindungen uebertragen
werden.

------------------------ SCHNAPP -------------------------
Prima, also eine Pruefsumme ueber einen Block. sollte ja nicht so schwer
sein, also interessiert mich natuerlich, wie ich eine "16-Bit CRC nach
X-MODEM Polynom" berechnen kann. Und man wird fuendig :

------------------------ SCHNIPP -------------------------
Message-ID Konvertierung

/*----------------------------- msgid.c -----------------------*/
/*
 *  MsgID.c
 *
 *  ID-Konvertierung fuer die Wandlung ZCONNECT -> Z-NETZ
 */


# include <stdio.h>
# ifndef OSK
# include <stdlib.h>
# endif
# include <string.h>
# include "crc.h"

static char sextet[] =  "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
              "abcdefghijklmnopqrstuvwxyz"
              "0123456789+/";

# define SEXT_MASK 0x003fl      /* 6 Bit */
# define LOW28_MASK0x0fffffffl   /* 28 Bit */
# define LOW2_MASK 0x00000003l   /* 2 Bit */

void
convert_id(char *zerb_id, char *zconnect_id)
{
     unsigned char *p;
     unsigned long crc, crc2;

     if (*zconnect_id == '<')
          zconnect_id++;
     crc2 = crc = 0xffffffffl;
     for (p=zconnect_id; *p; p++) {
          if (*p == '@' || *p == '>') break;
          crc = UPDC32(*p, crc);
     }
     crc = ~crc;

     if (*p != '@')
          crc2 = 0;
     else {
          for (p++; *p; p++) {
              if (*p == '>') break;
              crc2 = UPDC32(*p, crc2);
          }
          crc2 = (~crc2) & LOW28_MASK;
     }

#ifdef DEBUG
     printf ("\nMessage-ID:\t%s\nlinker CRC:\t%08lx\nrechter CRC:\t%08lx\n",
          zconnect_id, crc, crc2);


#endif

     zerb_id[9] = sextet[(int)(crc2 & SEXT_MASK)]; crc2 >>= 6;
     zerb_id[8] = sextet[(int)(crc2 & SEXT_MASK)]; crc2 >>= 6;
     zerb_id[7] = sextet[(int)(crc2 & SEXT_MASK)]; crc2 >>= 6;
     zerb_id[6] = sextet[(int)(crc2 & SEXT_MASK)]; crc2 >>= 6;

     crc2 |= (crc & LOW2_MASK) << 4;
     zerb_id[5] = sextet[(int)(crc2 & SEXT_MASK)]; crc >>= 2;

     zerb_id[4] = sextet[(int)(crc & SEXT_MASK)]; crc >>= 6;
     zerb_id[3] = sextet[(int)(crc & SEXT_MASK)]; crc >>= 6;
     zerb_id[2] = sextet[(int)(crc & SEXT_MASK)]; crc >>= 6;
     zerb_id[1] = sextet[(int)(crc & SEXT_MASK)]; crc >>= 6;
     zerb_id[0] = sextet[(int)(crc & SEXT_MASK)];

     strcpy(zerb_id+10, "@" host);
}

#ifdef TEST_ID_MAIN

main()
{
     char msgid[200], z_id[30], datum[80];

     printf ("Test Message-ID Erzeugung:\n");
     printf ("Bitte ZCONNECT-Id eingeben:\t"); gets(msgid);
     convert_id(z_id, msgid);
     printf ("Zerberus-ID:\t%s\n", z_id);

     return 0;
}
#endif
------------------------ SCHNAPP -------------------------

Hurra - da die Box selbst mehr oder weniger fast identisch mit dem
Z-Netz-Format aufgebaut ist, brauche ich dieses zumindest fuer die
Konvertierung von ZCONNECT-Nachrichten. Leider war der letzte Absatz fuer
mich spanisch - nur dass staendig dieses crc gebraucht wird, und das findet
sich in "crc.h" zum Implementieren, das also ist dieses X-Modem Polynom :

------------------------ SCHNIPP -------------------------
/*
 *  crc.h
 *
 *  Aus den Z-MODEM Sourcen, (C) Chuck Forresberg
 */

typedef unsigned long ULONG;

/* First, the polynomial itself and its table of feedback terms.  The  */
/* polynomial is						       */
/* X^32+X^26+X^23+X^22+X^16+X^12+X^11+X^10+X^8+X^7+X^5+X^4+X^2+X^1+X^0 */
/* Note that we take it "backwards" and put the highest-order term in  */
/* the lowest-order bit.  The X^32 term is "implied"; the LSB is the   */
/* X^31 term, etc.  The X^0 term (usually shown as "+1") results in    */
/* the MSB being 1.						       */

/* Note that the usual hardware shift register implementation, which   */
/* is what we're using (we're merely optimizing it by doing eight-bit  */
/* chunks at a time) shifts bits into the lowest-order term.  In our   */
/* implementation, that means shifting towards the right.  Why do we   */
/* do it this way?  Because the calculated CRC must be transmitted in  */
/* order from highest-order term to lowest-order term.	UARTs transmit */
/* characters in order from LSB to MSB.  By storing the CRC this way,  */
/* we hand it to the UART in the order low-byte to high-byte; the UART */
/* sends each low-bit to hight-bit; and the result is transmission bit */
/* by bit from highest- to lowest-order term without requiring any bit */
/* shuffling on our part.  Reception works similarly.		       */

/* The feedback terms table consists of 256, 32-bit entries.  Notes:   */
/*								       */
/*     The table can be generated at runtime if desired; code to do so */
/*     is shown later.	It might not be obvious, but the feedback      */
/*     terms simply represent the results of eight shift/xor opera-    */
/*     tions for all combinations of data and CRC register values.     */
/*								       */
/*     The values must be right-shifted by eight bits by the "updcrc"  */
/*     logic; the shift must be unsigned (bring in zeroes).  On some   */
/*     hardware you could probably optimize the shift in assembler by  */
/*     using byte-swap instructions.				       */

ULONG crc_32_tab[] = { /* CRC polynomial 0xedb88320 */
	0x00000000L, 0x77073096L, 0xee0e612cL, 0x990951baL,
	0x076dc419L, 0x706af48fL, 0xe963a535L, 0x9e6495a3L,
	0x0edb8832L, 0x79dcb8a4L, 0xe0d5e91eL, 0x97d2d988L,
....
	0xbad03605L, 0xcdd70693L, 0x54de5729L, 0x23d967bfL,
	0xb3667a2eL, 0xc4614ab8L, 0x5d681b02L, 0x2a6f2b94L,
	0xb40bbe37L, 0xc30c8ea1L, 0x5a05df1bL, 0x2d02ef8dL
};


#define UPDC32(octet, crc) \
(crc_32_tab[(unsigned)((((ULONG)crc) ^ ((ULONG)octet)) & 0xff)] ^ (((ULONG)crc) >> 8))
------------------------ SCHNAPP -------------------------

HIIIIIIIIIIIIIIILFEEEEEEEEEEEEE.......... da hier wohl bis auf Tec keiner
so sonderlich viel Ahnung von GFA hat, kann mir ja vielleicht irgendjemand
irgendwie anders helfen bzw. das logischer darstellen ????

Danke fuer JEDE Hilfe,

       Timo Junior (!)

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Ciao,
                           Kay

 Fuer eine Empfangbestaetigung bitte ## als Betreffanfang eingeben.
 Fido: Kay_Gehrke%2:2403_10.40              Z-Netz: K.Gehrke@BAMP.zer
 UUCP: k.gehrke@bamp.berlinet.in-berlin.de  -- THE ANSWER V2.03