source: abuse/tags/pd/macabuse/src/net/mac/adsptst.c @ 49

Last change on this file since 49 was 49, checked in by Sam Hocevar, 12 years ago
  • Imported original public domain release, for future reference.
  • Property svn:keywords set to Id
File size: 9.2 KB
Line 
1#include <AppleTalk.h>
2#include <ADSP.h>
3#include <stdio.h>
4#include <stdlib.h>
5#include <stdarg.h>
6#include <string.h>
7
8int eprintf(char *form, ...)
9{
10        va_list arg;
11       
12        va_start(arg,form);
13        vfprintf(stderr,form,arg);
14        va_end(arg);
15       
16        exit(0);
17
18        return 0;
19}
20
21#define assert(x,y) ((x)? 0 : eprintf("Line %d: %s, error\n",__LINE__, y))
22#define macerr(x,y) ((x)? eprintf("Line %d: %s, error %d\n",__LINE__, y, x) : 0)
23
24unsigned char *pstrcpy(unsigned char *d, unsigned char *s)
25{
26        unsigned int i = (unsigned char)s[0];
27
28        BlockMove(s,d,i+1);
29       
30        return d;
31}
32
33#define qSize   600     // queue space
34
35unsigned char   *dspSendQPtr;
36unsigned char   *dspRecvQPtr;
37unsigned char   *dspAttnBufPtr;
38unsigned char   *myData2ReadPtr;
39unsigned char   *myData2WritePtr;
40unsigned char   *myAttnMsgPtr;
41
42DSPPBPtr        myDSPPBPtr;
43MPPPBPtr        myMPPPBPtr;
44
45short   drvrRefNum;
46short   mppRef;
47short   connRefNum;
48
49Boolean gReceivedAnEvent;
50TRCCB   gDspCCB;
51
52void DoWrite(char *buff, short size)
53{
54        // the connection with the chosen socket is open, so now send to
55        //  the send queue exactly myDataSize number of bytes
56
57        // set up dspWrite parameters
58
59        fprintf(stderr,"Writing Data\n");
60       
61        myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
62        myDSPPBPtr->csCode = dspWrite;
63        myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
64        myDSPPBPtr->u.ioParams.reqCount = size;
65                                                        // write this numberof bytes
66        myDSPPBPtr->u.ioParams.dataPtr = buff;  // pointer to
67                                                                                // send queue
68        myDSPPBPtr->u.ioParams.eom = 1; // 1 means last byte is logical
69                                                                // end-of-message
70        myDSPPBPtr->u.ioParams.flush = 1;       // 1 means send data now
71
72        macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Write error");
73                                                                // send data to the remote connection
74}
75
76void DoRead(char *buff, short size)
77{
78        // Now read from the receive queue exactly myDataSize number of bytes.
79
80        fprintf(stderr,"Reading Data\n");
81       
82        // set up dspRead parameters
83        myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
84        myDSPPBPtr->csCode = dspRead;
85        myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
86        myDSPPBPtr->u.ioParams.reqCount = size;
87                                                                // read this number of bytes
88        myDSPPBPtr->u.ioParams.dataPtr = (Ptr)buff;     // pointer to
89                                                                                // read buffer
90
91        macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "read error");
92                                                        // read data from the remote  connection
93}
94
95int PickSocket(AddrBlock *addr)
96{
97        EntityName      entity;
98        char Buff[105];
99
100        NBPSetEntity((Ptr) &entity, "\p=", "\pAbuseServer", "\p*");
101       
102        myMPPPBPtr->NBPinterval = 7;// retransmit every 7*8=56 ticks
103        myMPPPBPtr->NBPcount = 3;       // and retry 3 times
104        myMPPPBPtr->NBPentityPtr = (Ptr) &entity;
105        myMPPPBPtr->NBPretBuffPtr = (Ptr) Buff;
106        myMPPPBPtr->NBPretBuffSize = sizeof(Buff);
107        myMPPPBPtr->NBPmaxToGet = 1;
108
109        macerr(PLookupName(myMPPPBPtr,0), "Lookup error");
110               
111        macerr(NBPExtract((Ptr)Buff,myMPPPBPtr->NBPnumGotten,1,&entity,addr),"Extraction error");
112
113        for (int i=0; i<entity.objStr[0]; i++)
114                Buff[i] = entity.objStr[1+i];
115        Buff[entity.objStr[0]] = 0;
116       
117        fprintf(stderr,"Found [%s]\n",Buff);
118
119        return (myMPPPBPtr->NBPnumGotten == 1);
120}
121
122void main ()
123{
124        NamesTableEntry myNTEName;
125        AddrBlock       myAddrBlk;
126        short   myAttnCode;
127        Byte    tempFlag;
128        short   tempCFlag;
129
130        fprintf(stderr,"Open MPP\n");
131        macerr(OpenDriver("\p.MPP", &mppRef), "MPP Open Error");        // open .MPP driver
132        fprintf(stderr,"Open DSP\n");
133        macerr(OpenDriver("\p.DSP", &drvrRefNum), "DSP Open Error");    // open .DSP driver
134
135        // allocate memory for data buffers
136        fprintf(stderr,"Alloc structures\n");
137
138        dspSendQPtr = (unsigned char *) NewPtr(qSize);  // ADSP use only
139        dspRecvQPtr = (unsigned char *) NewPtr(qSize);  // ADSP use only
140        dspAttnBufPtr = (unsigned char *) NewPtr(attnBufSize);// ADSP use only
141        myAttnMsgPtr = (unsigned char *) NewPtr(128);
142        myDSPPBPtr = (DSPPBPtr) NewPtr(sizeof(DSPParamBlock));
143        myMPPPBPtr = (MPPPBPtr) NewPtr(sizeof(MPPParamBlock));
144
145        // set up dspInit parameters
146
147        fprintf(stderr,"DSP init\n");
148
149        myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
150        myDSPPBPtr->csCode = dspInit;
151        myDSPPBPtr->u.initParams.ccbPtr = (TPCCB) &gDspCCB;     // ptr to CCB
152
153        // don't handle exceptions for now
154        myDSPPBPtr->u.initParams.userRoutine = 0;
155//      myDSPPBPtr->u.initParams.userRoutine = &myConnectionEvtUserRoutine;
156
157        myDSPPBPtr->u.initParams.sendQSize = qSize;     // size of send queue
158        myDSPPBPtr->u.initParams.sendQueue = dspSendQPtr;// send-queue buffer
159        myDSPPBPtr->u.initParams.recvQSize = qSize;     // size of receive queue
160        myDSPPBPtr->u.initParams.recvQueue = dspRecvQPtr;       // receive-queue
161                                                                                                                //buffer
162        myDSPPBPtr->u.initParams.attnPtr = dspAttnBufPtr;       // receive-
163                                                                                                                //attention buffer
164        myDSPPBPtr->u.initParams.localSocket = 0;       // let ADSP assign socket
165
166        gReceivedAnEvent = FALSE;
167//      gDspCCB.myA5 = SetCurrentA5();  // save A5 for the user routine
168
169        // establish a connection end
170
171        macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Initialization Error");
172
173        connRefNum = myDSPPBPtr->ccbRefNum;     // save CCB ref num for later
174
175        short node,net;
176        Str255 name;
177       
178        fprintf(stderr,"Get Address...");       
179        macerr(GetNodeAddress(&node,&net),"Can't get node address");
180        sprintf((char*)&name[1],"Abuse@%d:%d:%d",net,node,myDSPPBPtr->u.initParams.localSocket);
181        name[0] = strlen((char*)&name[1]);
182
183        fprintf(stderr,"I'm %s\n",&name[1]);
184       
185        NBPSetNTE((Ptr) &myNTEName, "\pA1", "\pAbuseServer", "\p*",
186                        myDSPPBPtr->u.initParams.localSocket);
187                        // set up NBP names table entry
188
189        // set up PRegisterName parameters
190
191        fprintf(stderr,"Registering Name...");
192
193        myMPPPBPtr->NBP.interval = 7;// retransmit every 7*8=56 ticks
194        myMPPPBPtr->NBP.count = 3;      // and retry 3 times
195        myMPPPBPtr->NBP.nbpPtrs.entityPtr = (Ptr) &myNTEName;
196                                                                // name to register
197        myMPPPBPtr->NBP.parm.verifyFlag = 1;    // verify this name
198
199        if (PRegisterName(myMPPPBPtr, FALSE) == noErr)
200        {
201                fprintf(stderr,"Ok.\n");
202                fprintf(stderr,"Waiting for connection...");
203                               
204                // open a connection passive
205       
206                // set up dspOpen parameters
207       
208                myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
209                myDSPPBPtr->csCode = dspOpen;
210                myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
211       
212                myDSPPBPtr->u.openParams.filterAddress.aNet = 0;
213                myDSPPBPtr->u.openParams.filterAddress.aNode = 0;
214                myDSPPBPtr->u.openParams.filterAddress.aSocket = 0;
215                                                        // address filter, don't filter
216       
217                myDSPPBPtr->u.openParams.ocMode = ocPassive;    // open connection
218                                                                                        //mode
219                myDSPPBPtr->u.openParams.ocInterval = 7;        // use default retry interval
220                myDSPPBPtr->u.openParams.ocMaximum = 3;
221                                                                                // use default retry maximum
222       
223                macerr(PBControl((ParmBlkPtr)myDSPPBPtr, FALSE), "dspOpen error");
224                                                                        // open a connection
225                                                                       
226                myAddrBlk = myDSPPBPtr->u.openParams.remoteAddress;
227                fprintf(stderr,"Found %d:%d:%d\n",myAddrBlk.aNet,myAddrBlk.aNode,myAddrBlk.aSocket);
228        }
229        else
230        {
231                fprintf(stderr,"Failed.\n");
232                fprintf(stderr,"Searching for connection...");
233                               
234        // set up dspOptions parameters
235
236//      myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
237//      myDSPPBPtr->csCode = dspOptions;
238//      myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
239//      myDSPPBPtr->u.optionParams.sendBlocking = blockFact;
240                                                                // quantum for data packet
241//      myDSPPBPtr->u.optionParams.badSeqMax = 0;       // use default
242//      myDSPPBPtr->u.optionParams.useCheckSum = 0;     // don't calculate
243                                                                                                        //checksum
244
245//      macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "Set Options error");
246                                                                                // set options
247
248                // routine using the PLookupName function to pick a socket
249                // that will be used to establish an open connection
250
251                assert(PickSocket(&myAddrBlk),"Can't find socket");
252
253                fprintf(stderr,"Found %d:%d:%d\n",myAddrBlk.aNet,myAddrBlk.aNode,myAddrBlk.aSocket);
254
255                // open a connection with the chosen socket
256       
257                // set up dspOpen parameters
258
259                fprintf(stderr,"Opening Socket\n");
260       
261                myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
262                myDSPPBPtr->csCode = dspOpen;
263                myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
264                myDSPPBPtr->u.openParams.remoteAddress = myAddrBlk;
265                                                //address of remote socket from PLookupName function
266       
267                myDSPPBPtr->u.openParams.filterAddress = myAddrBlk;
268                                                        // address filter, specified socket address only
269       
270                myDSPPBPtr->u.openParams.ocMode = ocRequest;    // open connection
271                                                                                        //mode
272                myDSPPBPtr->u.openParams.ocInterval = 0;        // use default retry interval
273                myDSPPBPtr->u.openParams.ocMaximum = 0;
274                                                                                // use default retry maximum
275       
276                macerr(PBControl((ParmBlkPtr)myDSPPBPtr, FALSE), "dspOpen error");
277                                                                        // open a connection
278        }
279       
280        char st[80];
281       
282        DoWrite("Hello, other!",14);
283       
284        DoRead(st,sizeof(st));
285
286        fprintf(stderr,"Got [%s]\n",st);
287
288        // we're done with the connection, so remove it
289
290        // set up dspRemove parameters
291
292        fprintf(stderr,"Removing Connection\n");
293
294        myDSPPBPtr->ioCRefNum = drvrRefNum;     // ADSP driver ref num
295        myDSPPBPtr->csCode = dspRemove;
296        myDSPPBPtr->ccbRefNum = connRefNum;     // connection ref num
297        myDSPPBPtr->u.closeParams.abort = 0;    // don't close until everything
298                                                                        //is sent and received
299
300        macerr(PBControl((ParmBlkPtr) myDSPPBPtr, FALSE), "remove error");
301                                                                        // close and remove the connection
302
303        // you're done with this connection, so give back the memory
304        DisposPtr((Ptr) dspSendQPtr);
305        DisposPtr((Ptr) dspRecvQPtr);
306        DisposPtr((Ptr) dspAttnBufPtr);
307        DisposPtr((Ptr) myData2ReadPtr);
308        DisposPtr((Ptr) myData2WritePtr);
309        DisposPtr((Ptr) myAttnMsgPtr);
310        DisposPtr((Ptr) myDSPPBPtr);
311        DisposPtr((Ptr) myMPPPBPtr);
312
313        fprintf(stderr,"Done.\n");
314}       // MyADSP
315
Note: See TracBrowser for help on using the repository browser.