From: Theodore Tso Date: Fri, 30 May 1997 23:10:14 +0000 (+0000) Subject: Check in Miro's new gss sample code X-Git-Tag: krb5-1.1-beta1~1132 X-Git-Url: http://git.tremily.us/?a=commitdiff_plain;h=9ea69a68371057fa5bdfde82c677da6760586486;p=krb5.git Check in Miro's new gss sample code git-svn-id: svn://anonsvn.mit.edu/krb5/trunk@10092 dc483132-0cff-0310-8789-dd5450dbe970 --- diff --git a/src/mac/gss/CGSSDocument.cp b/src/mac/gss/CGSSDocument.cp new file mode 100644 index 000000000..ea46cbc4d --- /dev/null +++ b/src/mac/gss/CGSSDocument.cp @@ -0,0 +1,925 @@ +#include "CGSSDocument.h" + +#include +#include +#include +#include + +extern "C" { +#include +} + +#include "CGSSWindow.h" + +const ResIDT wind_GSS = 128; +const PaneIDT pane_Status = 904; +const PaneIDT pane_QueryArgument = 900; +const PaneIDT pbut_Query = 901; +const PaneIDT text_Output = 903; +// Message the Query button broadcasts +const MessageT msg_Query = 'GSSq'; +// AppleEvent reference number +const long ae_Query = 4001; + +CGSSDocument::CGSSDocument () +{ + // Make us a window + mWindow = CGSSWindow::CreateGSSWindow (wind_GSS, this); + + // A window, I said + SignalIf_ (mWindow == nil); + mWindow -> Show (); + + // Listen to query button clicks + ((LControl*) mWindow -> FindPaneByID (pbut_Query)) -> AddListener (this); +} + +CGSSDocument::~CGSSDocument () +{ +} + +void +CGSSDocument::HandleAppleEvent ( + const AppleEvent& inAppleEvent, + AppleEvent& outAEReply, + AEDesc& outResult, + long inAENumber) +{ + switch (inAENumber) { + + case ae_Query: + // extract the query string from the appleevent + AEDesc queryData; + OSErr err = ::AEGetParamDesc (&inAppleEvent, keyDirectObject, typeChar, &queryData); + char queryString [255]; + UInt8 dataSize; + { + StHandleLocker (queryData.dataHandle); + dataSize = ::GetHandleSize (queryData.dataHandle); + // Limited to 255 charactees + SignalIf_ (dataSize > 255); + ::BlockMoveData (*(queryData.dataHandle), queryString, dataSize); + } + + queryString [dataSize] = '\0'; + + GSSQuery (queryString); + ::AEDisposeDesc (&queryData); + break; + + default: + LSingleDoc::HandleAppleEvent (inAppleEvent, outAEReply, outResult, inAENumber); + break; + } +} + +Boolean +CGSSDocument::ObeyCommand( + CommandT inCommand, + void *ioParam) +{ + Boolean cmdHandled = true; + + switch (inCommand) { + + // Deal with command messages + // Any that you don't handle will be passed to LApplication + + case msg_Query: + Str255 theArgument = "\0"; + (LEditField*) (mWindow -> FindPaneByID (pane_QueryArgument)) -> GetDescriptor (theArgument); + P2CStr (theArgument); + GSSQuery ((char*) theArgument); + break; + + default: + cmdHandled = LSingleDoc::ObeyCommand(inCommand, ioParam); + break; + } + + return cmdHandled; + +} + +void +CGSSDocument::DoAESave( + FSSpec& inFileSpec, + OSType inFileType) +{ + TEHandle teHandle = ((LTextEdit*) (mWindow -> FindPaneByID (text_Output))) -> GetMacTEH (); + Handle textHandle = (*teHandle) -> hText; + UInt32 textSize = ::GetHandleSize (textHandle); + + LFileStream saveStream (inFileSpec); + try + { + // Try opening the file + saveStream.OpenDataFork (fsRdWrPerm); + } + Catch_ (err) + { + // If opening failed, try creating the file + saveStream.CreateNewDataFile ('CWIE', 'TEXT', smSystemScript); + saveStream.OpenDataFork (fsRdWrPerm); + } + + saveStream.SetLength (0); // Zap! + + StHandleLocker dataLock (textHandle); + saveStream.WriteData (*textHandle, (*teHandle) -> teLength); + SetModified (false); +} + +void +CGSSDocument::ListenToMessage ( + MessageT inMessage, + void* ioParam) +{ + switch (inMessage) + { + case msg_Query: + // Respond to query button clicks by doing the query + ObeyCommand (msg_Query, nil); + } +} + +// The following two append strings to the output TextEdit pane + +void +CGSSDocument::AppendPString ( + ConstStringPtr inString) +{ + TEHandle teHandle = ((LTextEdit*) (mWindow -> FindPaneByID (text_Output))) -> GetMacTEH (); + Handle textHandle = (*teHandle) -> hText; + UInt32 textSize = ::GetHandleSize (textHandle); + ::SetHandleSize (textHandle, textSize + inString [0]); + + { + StHandleLocker textLock (textHandle); + ::BlockMoveData (inString + 1, *textHandle + textSize, inString [0]); + } + (*teHandle) -> teLength += inString [0]; + ::TECalText (teHandle); + + mWindow -> Refresh (); +} + +void +CGSSDocument::AppendCString ( + char* inString) +{ + C2PStr (inString); + AppendPString ((ConstStringPtr) inString); +} + +#pragma mark - +#pragma mark € GSS Functions € + +void +CGSSDocument::GSSQuery ( + char* inQueryString) +{ + Boolean validQuery = true; + + char serverHost [255]; + memset (serverHost, 0, 255); + + char serviceName [255]; + memset (serviceName, 0, 255); + + char theMessage [255]; + memset (theMessage, 0, 255); + + u_short serverPort = 4444; + int useV2 = 0; + char* walker; + + char* argWalker = inQueryString; + + // check all options + while (*argWalker == '-') + { + // eat leading space + while (*argWalker != '\0' && isspace (*argWalker)) + argWalker++; + + // check -v2 option + if (!strncmp (argWalker, "-v2 ", 4)) + { + useV2 = 1; + argWalker += 4; + continue; + }; + + // check -port option + if (!strncmp (argWalker, "-port ", 6)) + { + // skip "-port " + argWalker +=6; + // skip space + while (*argWalker != '\0' && isspace (*argWalker)) + argWalker++; + // copy the port number; recycle serverHost for this + for (walker = serverHost; *argWalker != '\0' && !isspace (*argWalker); argWalker++, walker++) + *walker = *argWalker; + + if (*serverHost == '\0') + validQuery = false; + serverPort = atoi (serverHost); + memset (serverHost, 0, 255); + } + } + + // eat leading space + while (*argWalker != '\0' && isspace (*argWalker)) + argWalker++; + + // Copy to serverHost + for (walker = serverHost; (*argWalker != '\0' && !isspace (*argWalker)); argWalker++, walker++) + *walker = *argWalker; + if (*serverHost == '\0') + validQuery = false; + + // eat leading space + while (*argWalker != '\0' && isspace (*argWalker)) + argWalker++; + + // Copy to serviceName + for (walker = serviceName; (*argWalker != '\0' && !isspace (*argWalker)); argWalker++, walker++) + *walker = *argWalker; + if (*serviceName == '\0') + validQuery = false; + + // eat leading space + while (*argWalker != '\0' && isspace (*argWalker)) + argWalker++; + + // Copy to theMessage + for (walker = theMessage; (*argWalker != '\0' && !isspace (*argWalker)); argWalker++, walker++) + *walker = *argWalker; + if (*theMessage == '\0') + validQuery = false; + + SetModified (true); + + if (!GSSCallServer(serverHost, serverPort, useV2, serviceName, theMessage) < 0) + AppendPString ("\pQuery Complete =)"); +} + +/* + * Function: call_server + * + * Purpose: Call the "sign" service. + * + * Arguments: + * + * host (r) the host providing the service + * port (r) the port to connect to on host + * service_name (r) the GSS-API service name to authenticate to + * msg (r) the message to have "signed" + * + * Returns: 0 on success, -1 on failure + * + * Effects: + * + * call_server opens a TCP connection to and establishes a + * GSS-API context with service_name over the connection. It then + * seals msg in a GSS-API token with gss_seal, sends it to the server, + * reads back a GSS-API signature block for msg from the server, and + * verifies it with gss_verify. -1 is returned if any step fails, + * otherwise 0 is returned. + */ + // meeroh: put this in CGSSDocument for easier access to Stderr + // could have done in a different way; this simplifies the code +int +CGSSDocument::GSSCallServer ( + char *host, + u_short port, + int dov2, + char *service_name, + char *msg) +{ + gss_ctx_id_t context; + gss_buffer_desc in_buf, out_buf, context_token; + int state; + int s; + OM_uint32 maj_stat, min_stat; + gss_name_t src_name, targ_name; + gss_buffer_desc sname, tname; + OM_uint32 lifetime; + gss_OID mechanism; + int is_local; +#ifdef GSSAPI_V2 + OM_uint32 context_flags; + int is_open; + gss_qop_t qop_state; + gss_OID_set mech_names; + gss_buffer_desc oid_name; +#else /* GSSAPI_V2 */ + int context_flags; +#endif /* GSSAPI_V2 */ + char msgString [255] = "\0"; + + /* Open connection */ + if ((s = GSSConnectToServer (host, port)) == (int) -1) + return -1; + + /* Establish context */ + if (GSSClientEstablishContext (s, service_name, &context) < 0) + return -1; + +#ifdef GSSAPI_V2 + if (dov2) + { + /* + * Attempt to save and then restore the context. + */ + maj_stat = gss_export_sec_context ( &min_stat, + &context, + &context_token); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus("exporting context", maj_stat, min_stat); + return -1; + } + maj_stat = gss_import_sec_context ( &min_stat, + &context_token, + &context); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("importing context", maj_stat, min_stat); + return -1; + } + (void) gss_release_buffer (&min_stat, &context_token); + } +#endif /* GSSAPI_V2 */ + + /* Get context information */ + maj_stat = gss_inquire_context ( &min_stat, + context, + &src_name, + &targ_name, + &lifetime, + &mechanism, + &context_flags, + &is_local +#ifdef GSSAPI_V2 + , &is_open +#endif /* GSSAPI_V2 */ + ); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("inquiring context", maj_stat, min_stat); + return -1; + } + + maj_stat = gss_display_name ( &min_stat, + src_name, + &sname, + (gss_OID *) NULL); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("displaying context", maj_stat, min_stat); + return -1; + } + maj_stat = gss_display_name ( &min_stat, + targ_name, + &tname, + (gss_OID *) NULL); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("displaying context", maj_stat, min_stat); + return -1; + } + + sprintf ( msgString, + "\"%s\" to \"%s\"\r lifetime %d, flags %x, %s", + sname.value, + tname.value, + lifetime, + context_flags, + (is_local) ? "locally initiated" : "remotely initiated"); + AppendCString (msgString); +#ifdef GSSAPI_V2 + sprintf (msgString, " %s", (is_open) ? "open" : "closed"); + AppendCString (msgString); +#endif /* GSSAPI_V2 */ + sprintf(msgString, "\r"); + AppendCString (msgString); + + (void) gss_release_name (&min_stat, &src_name); + (void) gss_release_name (&min_stat, &targ_name); + (void) gss_release_buffer (&min_stat, &sname); + (void) gss_release_buffer(&min_stat, &tname); + +#ifdef GSSAPI_V2 + if (dov2) + { + size_t i; + + /* Now get the names supported by the mechanism */ + maj_stat = gss_inquire_names_for_mech ( &min_stat, + mechanism, + &mech_names); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("inquiring mech names", maj_stat, min_stat); + return -1; + } + + maj_stat = gss_oid_to_str ( &min_stat, + mechanism, + &oid_name); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("converting oid->string", maj_stat, min_stat); + return -1; + } + + sprintf ( msgString, + "Mechanism %s supports %d names\r", + oid_name.value, + mech_names->count); + AppendCString (msgString); + (void) gss_release_buffer(&min_stat, &oid_name); + for (i=0; icount; i++) + { + gss_OID tmpoid; + int is_present; + + maj_stat = gss_oid_to_str ( &min_stat, + &mech_names->elements[i], + &oid_name); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("converting oid->string", maj_stat, min_stat); + return -1; + } + + sprintf (msgString, "%d: %s\r", i, oid_name.value); + AppendCString (msgString); + + maj_stat = gss_str_to_oid ( &min_stat, + &oid_name, + &tmpoid); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ( "converting string->oid", + maj_stat, + min_stat); + return -1; + } + + maj_stat = gss_test_oid_set_member ( &min_stat, + tmpoid, + mech_names, + &is_present); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("testing oid presence", maj_stat, min_stat); + return -1; + } + if (!is_present) + { + sprintf (msgString, "%s is not present in list?\r", oid_name.value); + AppendCString (msgString); + } + (void) gss_release_oid (&min_stat, &tmpoid); + (void) gss_release_buffer (&min_stat, &oid_name); + } + + (void) gss_release_oid_set (&min_stat, &mech_names); + (void) gss_release_oid (&min_stat, &mechanism); + } +#endif /* GSSAPI_V2 */ + + /* Seal the message */ + in_buf.value = msg; + in_buf.length = strlen(msg) + 1; +#ifdef GSSAPI_V2 + if (dov2) + maj_stat = gss_wrap ( &min_stat, + context, + 1, + GSS_C_QOP_DEFAULT, + &in_buf, + &state, + &out_buf); + else +#endif /* GSSAPI_V2 */ + maj_stat = gss_seal ( &min_stat, + context, + 1, + GSS_C_QOP_DEFAULT, + &in_buf, + &state, + &out_buf); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ( "sealing message", maj_stat, min_stat); + return -1; + } + else + if (!state) + { + sprintf (msgString, "Warning! Message not encrypted.\r"); + AppendCString (msgString); + } + + /* Send to server */ + if (GSSSendToken (s, &out_buf) < 0) + return -1; + (void) gss_release_buffer (&min_stat, &out_buf); + + /* Read signature block into out_buf */ + if (GSSReceiveToken (s, &out_buf) < 0) + return -1; + + /* Verify signature block */ +#ifdef GSSAPI_V2 + if (dov2) + maj_stat = gss_verify_mic ( &min_stat, + context, + &in_buf, + &out_buf, + &qop_state); + else +#endif /* GSSAPI_V2 */ + maj_stat = gss_verify (&min_stat, context, &in_buf, &out_buf, &state); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("verifying signature", maj_stat, min_stat); + return -1; + } + (void) gss_release_buffer (&min_stat, &out_buf); + + AppendPString ("\pSignature verified.\r"); + + /* Delete context */ + maj_stat = gss_delete_sec_context (&min_stat, &context, &out_buf); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("deleting context", maj_stat, min_stat); + return -1; + } + (void) gss_release_buffer (&min_stat, &out_buf); + + close(s); + + return 0; +} + +void +CGSSDocument::GSSDisplayStatus ( + char *m, + OM_uint32 maj_stat, + OM_uint32 min_stat) +{ + OM_uint32 my_maj_stat, my_min_stat; + gss_buffer_desc msg; + #ifdef GSSAPI_V2 + OM_uint32 msg_ctx; + #else /* GSSAPI_V2 */ + int msg_ctx; + #endif /* GSSAPI_V2 */ + + Str255 msgString; + + msg_ctx = 0; + while (1) { + my_maj_stat = gss_display_status( + &my_min_stat, maj_stat, GSS_C_GSS_CODE, GSS_C_NULL_OID, &msg_ctx, &msg); + + sprintf ((char*) msgString, "GSS-API error %s: %s\r", m, (char *)msg.value); + C2PStr ((char*) msgString); + AppendPString (msgString); + + (void) gss_release_buffer(&min_stat, &msg); + + if (!msg_ctx) + break; + } + + msg_ctx = 0; + while (1) { + my_maj_stat = gss_display_status( + &my_min_stat, min_stat, GSS_C_MECH_CODE, GSS_C_NULL_OID, &msg_ctx, &msg); + + sprintf ((char*) msgString, "GSS-API error %s: %s\r", m, (char *)msg.value); + C2PStr ((char*) msgString); + AppendPString (msgString); + + (void) gss_release_buffer(&min_stat, &msg); + + if (!msg_ctx) + break; + } +} + +/* + * Function: connect_to_server + * + * Purpose: Opens a TCP connection to the name host and port. + * + * Arguments: + * + * host (r) the target host name + * port (r) the target port, in host byte order + * + * Returns: the established socket file desciptor, or -1 on failure + * + * Effects: + * + * The host name is resolved with gethostbyname(), and the socket is + * opened and connected. If an error occurs, an error message is + * displayed and -1 is returned. + */ +int CGSSDocument::GSSConnectToServer ( + char *host, + u_short port) +{ + struct sockaddr_in saddr; + struct hostent *hp; + int s; + char msgString [255]; + + if ((hp = gethostbyname (host)) == NULL) + { + sprintf (msgString, "Unknown host: %s\r", host); + AppendCString (msgString); + return (SOCKET) -1; + } + + saddr.sin_family = hp->h_addrtype; + memcpy ((char *) &saddr.sin_addr, hp -> h_addr, sizeof (saddr.sin_addr)); + saddr.sin_port = htons (port); + + if ((s = socket (AF_INET, SOCK_STREAM, 0)) == (SOCKET) -1) + { + sprintf (msgString, "Error creating socket\r"); + AppendCString (msgString); + return (SOCKET) -1; + } + if (connect (s, (struct sockaddr *) &saddr, sizeof (saddr)) < 0) + { + sprintf (msgString, "Error connecting to server\r"); + AppendCString (msgString); + return (SOCKET) -1; + } + return s; +} + + +/* + * Function: client_establish_context + * + * Purpose: establishes a GSS-API context with a specified service and + * returns the context handle + * + * Arguments: + * + * s (r) an established TCP connection to the service + * service_name (r) the ASCII service name of the service + * context (w) the established GSS-API context + * + * Returns: 0 on success, -1 on failure + * + * Effects: + * + * service_name is imported as a GSS-API name and a GSS-API context is + * established with the corresponding service; the service should be + * listening on the TCP connection s. The default GSS-API mechanism + * is used, and mutual authentication and replay detection are + * requested. + * + * If successful, the context handle is returned in context. If + * unsuccessful, the GSS-API error messages are displayed on stderr + * and -1 is returned. + */ +int CGSSDocument::GSSClientEstablishContext ( + SOCKET s, + char *service_name, + gss_ctx_id_t *gss_context) +{ + gss_buffer_desc send_tok, recv_tok, *token_ptr; + gss_name_t target_name; + OM_uint32 maj_stat, min_stat; + + /* + * Import the name into target_name. Use send_tok to save + * local variable space. + */ + send_tok.value = service_name; + send_tok.length = strlen (service_name) + 1; + maj_stat = gss_import_name ( &min_stat, + &send_tok, + (gss_OID) gss_nt_service_name, + &target_name); + if (maj_stat != GSS_S_COMPLETE) + { + GSSDisplayStatus ("parsing name", maj_stat, min_stat); + return -1; + } + + /* + * Perform the context-establishement loop. + * + * On each pass through the loop, token_ptr points to the token + * to send to the server (or GSS_C_NO_BUFFER on the first pass). + * Every generated token is stored in send_tok which is then + * transmitted to the server; every received token is stored in + * recv_tok, which token_ptr is then set to, to be processed by + * the next call to gss_init_sec_context. + * + * GSS-API guarantees that send_tok's length will be non-zero + * if and only if the server is expecting another token from us, + * and that gss_init_sec_context returns GSS_S_CONTINUE_NEEDED if + * and only if the server has another token to send us. + */ + + token_ptr = GSS_C_NO_BUFFER; + *gss_context = GSS_C_NO_CONTEXT; + + do + { + maj_stat = gss_init_sec_context ( &min_stat, + GSS_C_NO_CREDENTIAL, + gss_context, + target_name, + GSS_C_NULL_OID, + GSS_C_MUTUAL_FLAG | GSS_C_REPLAY_FLAG, + 0, + NULL, /* no channel bindings */ + token_ptr, + NULL, /* ignore mech type */ + &send_tok, + NULL, /* ignore ret_flags */ + NULL); /* ignore time_rec */ + + if (token_ptr != GSS_C_NO_BUFFER) + (void) gss_release_buffer (&min_stat, &recv_tok); + + if (maj_stat!=GSS_S_COMPLETE && maj_stat!=GSS_S_CONTINUE_NEEDED) + { + GSSDisplayStatus ("initializing context", maj_stat, min_stat); + (void) gss_release_name (&min_stat, &target_name); + return -1; + } + + if (send_tok.length != 0) + { + if (GSSSendToken(s, &send_tok) < 0) + { + (void) gss_release_buffer (&min_stat, &send_tok); + (void) gss_release_name (&min_stat, &target_name); + return -1; + } + } + (void) gss_release_buffer (&min_stat, &send_tok); + + if (maj_stat == GSS_S_CONTINUE_NEEDED) + { + if (GSSReceiveToken (s, &recv_tok) < 0) + { + (void) gss_release_name (&min_stat, &target_name); + return -1; + } + token_ptr = &recv_tok; + } + } + while (maj_stat == GSS_S_CONTINUE_NEEDED); + + (void) gss_release_name (&min_stat, &target_name); + return 0; +} + +/* + * Function: send_token + * + * Purpose: Writes a token to a file descriptor. + * + * Arguments: + * + * s (r) an open file descriptor + * tok (r) the token to write + * + * Returns: 0 on success, -1 on failure + * + * Effects: + * + * send_token writes the token length (as a network long) and then the + * token data to the file descriptor s. It returns 0 on success, and + * -1 if an error occurs or if it could not write all the data. + */ + +int CGSSDocument::GSSSendToken ( + SOCKET s, + gss_buffer_t tok) +{ + size_t ret; + char msgString [255]; + + ret = socket_write (s, (char *) &tok -> length, 4); + + if (ret < 0) + { + sprintf (msgString, "Error sending token length\r"); + AppendCString (msgString); + return -1; + } + else if (ret != 4) + { + sprintf (msgString, "sending token length: %d of %d bytes written\r", ret, 4); + AppendCString (msgString); + return -1; + } + +// meeroh: added the cast to char* + ret = send(s, (char*) tok -> value, tok -> length, 0); + + if (ret < 0) { + sprintf (msgString, "Error sending data\r"); + AppendCString (msgString); + return -1; + } + else if (ret != tok->length) + { + sprintf (msgString, "sending token data: %d of %d bytes written\r", ret, tok -> length); + AppendCString (msgString); + return -1; + } + + return 0; + +} /* send_token */ + + +/* + * Function: recv_token + * + * Purpose: Reads a token from a file descriptor. + * + * Arguments: + * + * s (r) an open file descriptor + * tok (w) the read token + * + * Returns: 0 on success, -1 on failure + * + * Effects: + * + * recv_token reads the token length (as a network long), allocates + * memory to hold the data, and then reads the token data from the + * file descriptor s. It blocks to read the length and data, if + * necessary. On a successful return, the token should be freed with + * gss_release_buffer. It returns 0 on success, and -1 if an error + * occurs or if it could not read all the data. + */ + +int +CGSSDocument::GSSReceiveToken ( + SOCKET s, + gss_buffer_t tok) +{ + int ret; + unsigned long len; + char msgString [255]; + + ret = socket_read(s, (char *) &len, 4); + + if (ret < 0) + { + sprintf (msgString, "Error reading token length\r"); + AppendCString (msgString); + return -1; + } + else if (ret != 4) + { + sprintf(msgString, "Error reading token length: %d of %d bytes read\r", ret, 4); + AppendCString (msgString); + return -1; + } + + tok->length = (size_t) len; + + tok->value = (char *) malloc(tok->length); + + if (tok->value == NULL) + { + sprintf (msgString, "Out of memory allocating token data\r"); + AppendCString (msgString); + return -1; + } + + ret = socket_read (s, (char *) tok->value, tok->length); + + if (ret < 0) + { + sprintf (msgString, "Error reading token data\r"); + AppendCString (msgString); + free (tok->value); + return -1; + } + + return 0; +} /* recv_token */ diff --git a/src/mac/gss/CGSSDocument.h b/src/mac/gss/CGSSDocument.h new file mode 100644 index 000000000..cc7afb93c --- /dev/null +++ b/src/mac/gss/CGSSDocument.h @@ -0,0 +1,57 @@ +#include +#include "gss.h" + +class CGSSDocument: + public LSingleDoc, + public LListener +{ + public: + CGSSDocument (); + ~CGSSDocument (); + void ListenToMessage ( + MessageT inMessage, + void* ioParam); + Boolean ObeyCommand ( + CommandT inCommand, + void *ioParam); + void GSSQuery ( + char* inQueryString); + void HandleAppleEvent ( + const AppleEvent& inAppleEvent, + AppleEvent& outAEReply, + AEDesc& outResult, + long inAENumber); + void DoAESave( + FSSpec& inFileSpec, + OSType inFileType); + + + private: + void AppendPString ( + ConstStringPtr inString); + void AppendCString ( + char* inString); + int GSSCallServer ( + char *host, + u_short port, + int dov2, + char *service_name, + char *msg); + void GSSDisplayStatus ( + char *msg, + OM_uint32 maj_stat, + OM_uint32 min_stat); + int GSSClientEstablishContext ( + SOCKET s, + char *service_name, + gss_ctx_id_t *gss_context); + SOCKET GSSConnectToServer ( + char *host, + u_short port); + int GSSSendToken( + SOCKET s, + gss_buffer_t tok); + int GSSReceiveToken ( + SOCKET s, + gss_buffer_t tok); +}; \ No newline at end of file diff --git a/src/mac/gss/CGSSWindow.cp b/src/mac/gss/CGSSWindow.cp new file mode 100644 index 000000000..49e7464a0 --- /dev/null +++ b/src/mac/gss/CGSSWindow.cp @@ -0,0 +1,52 @@ +#include "CGSSWindow.h" + +const PaneIDT text_Output = 903; + +CGSSWindow::CGSSWindow (): + LWindow () +{ +}; + +CGSSWindow::CGSSWindow ( + LStream* inStream): + LWindow (inStream) +{ +} + +CGSSWindow::~CGSSWindow () +{ +} + +CGSSWindow* +CGSSWindow::CreateGSSWindow ( + ResIDT inWindowID, + LCommander* inSuperCommander) +{ + return (CGSSWindow*) LWindow::CreateWindow (inWindowID, inSuperCommander); +} + +CGSSWindow* +CGSSWindow::CreateGSSWindowStream ( + LStream* inStream) +{ + return new CGSSWindow (inStream); +} + +Boolean +CGSSWindow::ObeyCommand ( + CommandT inCommand, + void *ioParam) +{ + switch (inCommand) + { + case cmd_Close: + // Quit when we close the window + // We shouldn't get this message because the close box is disabled + GetSuperCommander () -> ObeyCommand (cmd_Quit); + return true; + break; + + default: + return LWindow::ObeyCommand (inCommand, ioParam); + } +} diff --git a/src/mac/gss/CGSSWindow.h b/src/mac/gss/CGSSWindow.h new file mode 100644 index 000000000..8f3b0cde4 --- /dev/null +++ b/src/mac/gss/CGSSWindow.h @@ -0,0 +1,25 @@ +#include + +#pragma once + +class CGSSWindow: + public LWindow { +public: + enum { class_ID = 'GSSw' }; + CGSSWindow (); + CGSSWindow ( + LStream* inStream); + ~CGSSWindow (); + static CGSSWindow* CreateGSSWindow ( + ResIDT inWindowID, + LCommander* inSuperCommander); + static CGSSWindow* CreateGSSWindowStream ( + LStream* inStream); + + virtual Boolean ObeyCommand( + CommandT inCommand, + void *ioParam); +/* Boolean AttemptQuit ( + long inSaveOption);*/ + +}; \ No newline at end of file diff --git a/src/mac/gss/CW-Project.hqx b/src/mac/gss/CW-Project.hqx new file mode 100644 index 000000000..64e33c8be --- /dev/null +++ b/src/mac/gss/CW-Project.hqx @@ -0,0 +1,554 @@ +(This file must be converted with BinHex 4.0) +:#d&bBfKTGQ8ZFfPd!&0*9%46593K!*!%CeB!N!3aKe0*9#%!"!!!CeCb6'&e!J# +3""C#4!d0&8G6N!0KEA"XC5if1'XZBfCY,R"bDJ#!!*!%""-qG+@3!!#3&"TF!*! +%rj!%68e38N0A588"!+a9%Fq[Y-Z*!!![#`!!1AB!!![&!!!1%9Ide13!N!DYU!h +!V5H6di&XC3lNP&011GdX2%[jdk,GbZcXmeC#bj9T9rjQ+lZ9h9UE(Z%TBCSRTqH +a0Aq[AhNTfGTEZMdhLflc#%pbh+fEEEV*mDGeK2,,ccHbkH@QC%ZhlQ2A%jEEf*I +A`)YYXYPRkIEF!m*@i+X'FATeEKe&-ip(q(QE(GQRK'fbM`cf56E$N`f`'R!kk3* +J!*!!'`+i",pU6F20!arU1e8+"Z`fRb31dqG0aH[Yjqc,V9DVVGVRP[5M4Xr4fkq +Ue[[m,K@S`'bfc$#94[j2+LCFBcGfGUHcFQE+1S!aF`''*Veh13lJpTXE(VhM#Qd +l"m-Um[A$pF-V4RAfkJ0`kBU'YE0##@C,U@LYNYcZ8D-rLrf'kiHpLdX&N!$fVBB +R0Rk[h`5RaqB@,C0-*3&p3,,Kh843-IP3Td33q2p)Ad3*f9`N(jj88'-M0@VURAj +eH12MrPe(K5J5&3"34-jNBU526HqY#Al3a8KrK2#Im2qCV)iPU"Cdp0%KQPN`8YA +!(J-Ye[X$C&f(rr-JMN%)I88qS9"8CIeM#VRV,S"a)IVa+m4-3TcCkl(C[9d-#T! +!!iQX4E8`qRr2)65k+k&2XYPQRfB9b4UQ1$ec*2pl5-)G,"E6J3kCibf@+@FN9il +Im6kI@aN!KpNmTE#RMhD+Xd+F91hcqS0%lEiHCXZ8#3S"1%T04FS![-k`cYJ2m"- +F*F9P*@Tp4C@G,UMqF#qAq61r+F0[-TEmF0lQ(fN+E@kheqX4*dTZ(l9j-a6#qdE +3cRp&@#`5$)j$THFS$Kf0Z93d$6APjKj5Kia$d0YcFa8"F+MepL1%R-4"Y#X$m1V +V!R)#Kc6[##&r2E*HUcl9+aQ%M+1EMEk)`f,$M)TTmL#a-Umq@d!T!)HpLpNHALN +J%Bii`['"%ah(SG+rPj-kMRU'G-h(HJdFmHNiT'&mS*Vl0'rc&jmZ-dhVc6(*e'4 +#Gj*aH1derl-JRMrm!AphD$L')e$PVZMTSl88(f89F34V&!*`F(hU85AriG9#@Zc +*j!SJL4ZThGIM91)qK%-a)(&2+j`Xp[*"ml@MI#Kp*2H$V*j+lYdi6L6hAKc(NRX +[VmH5H`m1jBAN[Tq2IbEh3m4qNYalF"a,l[YKR%lZh6L8!j+lJ!2dbUPV&`,lD5Y +SCTGAKGif-UURYiQ3!,6Qkp$#XZ[QV@f%K#9)cZXmVq$p4Z00jBm`c58MU+lmNEJ +2#[p8iMlXX)S"LE[8kFNI,XiE2HT!iNlm4f*#)%HFiAKLkXCa)ZRdmR%XkI6J11l +Nqh'FG[*Z('TpYq[&)`i8IQmd2q-`-4aZCjIY[62C1+`d`Z'YF(AKQ&EKkX'4B$k +icK%9KpNd84'!p)pQ$I()"PId84cS91kZc*P#10bf3%!dHDYp6[Hll%DF!48YAD8 +)`1XCCiKPmZjXIaa(M`2hk#cQR-%ZQ4dl550`@mb+QeRaV"'A[JadKkNh,3AY9fT +Km`qTpKK6Ej5MKrEk+qAl'bQ3!$')AmdREpLM$V3h0SCV'hNrlCF`3Er-lm4-,p* +r8l0-p@Sa'kd5qb9(qTmmL,pjFlLrKISMVYIqh[rm'lpTA2D'"G,bF,Z1H-'0+jC +US$2(Ac&5c"mkE-c3-CFD'L'cqR&)c`HD$`KYGcG$TV80cV8X%Hkmm(%CblAVKEB +94F)GeAPB63dM(#qd,GZ+rAC-"%%)VAq*0Y85m!kI#iE@hlS%#XEjTKIP&e'GqZ0 +p[U3@D[YYP#EXCi6+iUf3!,CU#k(PpFc5,%ME'FqUK)eB,qGeH8q0piH8A&46VVc +peVE-"jQcm$[E*r1hE08pLl"AkR-&pb`5DPIA#EAY@,H3!!D5$)CUCh")`'ZIBi# +il2K3bjF[#lAF9)[I&GK',EamB6,@XN)YApf0hqFjCbfL,Y6b('+*VX[*Q&Th03U +Y[bi,YDcc#8[rf#`m[m*(Gl$A8SMlH4km''J@@Pr&1kmZKhj6jmPBAX$k0NZSKDV +,03!VbRH64PApNl(2+kV+M!Y3[dJ9l89Hj"'@2XeRTZ51f(F$'2ZZ96pm`eXFrp+ +f(,S[h0U(Ba0Z(V#C&#Zd[PD'[Ci&b$"LM`cmL[M9i6H,0B&U)VT!UDHkUV*#,"J +5Q1qa$lP-Y*UR@3`P9C,SNDi@cC0+a)SDTpXK"[f5C-#b!E0M6$K1MpeGij!!$%h +h"B8P9D6&Q#mdI6Y,D+V2kr#&TRTMc"F@0%Gp!I[[mi@QqSA`K6923GVh&pm`QYI +V),2bENMldlhS#dhBiKC)@I4X[4mSrJKiIhRSa`drLrT#8rd1X,fG$TRH(G`AQZU +Mi*!!R``8PfUB39jcX0Ei++ND,0kV*Er&EI0Jb5*Dr**GMR!1('6E(*)r32P"a4` +2j)&ZjL[iAFmRDSi("K&jS$Yl-0Cfi6FC8UmVJC6kjQ`N"ZXLX-'rLKUci`',A"m +FC,PVPJIXILHFJqD)rIN1TZ0"$%()$qmIMreA2JZkM0MqC2CY$aY[Ii48`h-'pRX +3G1H[C'0r8SHe$BL[M[Yr5RfYh"rjS2kk!C%45`B-i&Z`Qd'9H9J$Z@[U@F(m,G6 +3H01UhI59-6B'mC[$aMk'0p-f4$JYK(J0D!EUSMcTaT-6GBH8-$j`K(&3(6f2m,# +akclF-(N0!V!,fYMBDq,*3j!!rmA%#IDAmjEQJX@3!(,R[D3$cXFhQ*&rScSJ$3c +DSi')fQGkR(2a2ik2)cHi"JU+NTRph"(-RV'&&I4(KpAa55QcTbIr5`1'AmJTbal +'3AA5!1*K"41MkD9A!`86Ph-0f-r"UBN1q8QApIkZ"KjRCr0[K`D'(0#!GAiJ+&@ +,aI1#IPXJUJ0@p*dkjYS4a'm1-lf&i6re+FkGDpZrID$`L9fmi!VMS$TT!2'`ST9 +hrdd$43mYiKT`E8FI5(d+qqrhJ5GC#[r'0-$c3)l&lh9*pU"S$GU#6Up(mXmIC0K +l*kS5CBJm`-C1hkNNN!!(cYhM!cJ3p0[m6JNe6hNJV00S(P"@m)(La4NRID$m)ar +i!4[0[adqd'q2"QMbB%3X@e&hfME888k-X+L19BLad`GFff)qi0Uf#lqG2Z$DeZN +$b2%4(h"Ylr3"cNGl,KciZqXlI-#eAIB"VY(Y'a"IT`m3(rYm!-R8i%X259BR[5- +K&NV5QHdKaBk$-aLfp`d-CCDMLlbk%AdK3Mk*r#N0r2)l@ML,*-2[b$GDd8GBhii +h58k$(iG(hMGP#m[NfHURKr"%LqqrPi%iCIRMNEF[4q!%@DBp08DQcbpGjCbhGh! +HCCqrAG*qE`1kDhYGlV9F)FCJrRYQc`i%EIkZKe)8%-j)5'JArmQMfG03"fU9E+' +Xie8Df@MT"[e&@q@cBm82f6!GIlj(LHBm5F1,cYKNdMqkTmNlX5JF@A#`U3`3N!" +kC0XHS0k26hSHFZM0UH1!"%@!"jL83BkXQ)iRVMUIra,'#0QI)B9RXIY"43%8XL$ +6pcPD-f0cV58c"Z,rkp@[ab!*MIc**rT#dAH"pUiZS&Tj&Y$iFM,9[PJ,p1J"Ac) +CCi,Tq(FREliERih#)4b9F[5!$c@`+kM@CaQ1fB!YTCTd(q$L#Bi1LDF%Z"BJ[B# +E3""`UhJ!MaG6I`pI`rR8)UTGG"[FJc8qdSer!A!X0r"qUKQYX!TVI1`hr"Ci'[F +FH,r"$B#V!GRmAQ%*[)UeCkL@[a#f)TTkUK@R`*qapK,95SBcA+LjD"[9-XXBMJ` +[jKQMD"A$FGc&D9`6H3a(l4G[SYU#)%1qFYkN@[U,$%IRJakLfZM2XjPBqbAA34Z +0!#pj)bbTmdKr9&$[i2IiBNPIH4qde1Eh1$f9QXM3f1`-f2Y&LLM6!%k3!,9mj61 +k)*K%5lmQVd1kA2)NaKD!qE9`Cfd%J6b(MbYf1)0H[c$"k`R'PGMmP9*3-pjZPh$ +Vd'),9Z&phLD*hZm)!dZQ@T%cJ*Z*8R8&SNk-2Hl"qd53!-Sd4VJ*Pm1X"Z*-%mc +BV&piUcl5*9+2Y%QLTlSL`+R@!6cfMYGC9-)PDpi[6)"'INi'LI4)EJeZZNG4rKm +!N!-0`(LDecRYmr-bchS[VpFQ1FVVk18Jbr@i+kF[Qh31m06`c-1c@e2+m4QlY3M +E%KVCC%XffH5f6cMCP'`*[qc*eRdQf462j+Im)Rc5+H'Gj$Gj(Z&ZBph#cdljB1' +%[lr2*lFPYjp`FJbi%EYSDjpfpV@'hk`Mh%e'R0`qEb@862D4hm"N&AM&UV22CaK +q!&$`Gb,!iR6mRBBj$riQiprHKA5B$8N`-D1`[Yk[qe4,0`)R-"6I'eF80*AHqKS +2j0&)!Z3"6%m[-ZVUe%#eCJE[rTbA@UUT9XM8JR2Rh#hqfaf#Pq*4!eS`B1A0qib +A"01c5R@rPMFYVm)b0EAZR,j-8QmYVf5(&V##Rp8[aD8(,9+2q9r8Ed4&U,lH-+f +m"9r`dVb@lYFYA3Yq8HmdPejPUZER22)a(Eq)6XcplDr*G`aI"$$[kLL2!Z&jmP% +5`SrGk"h$3#P!YdMDRqiUp"'(b2I94pADiImlUZbT,&PA56+3!%5THdHkh%DejLr +@6FeR'@BRh'kGGS*6-32$'$@(89GAE82U'F&fklaR"(AH-j!!h+l9BaVeQQNeG'N +0[j)Q+[4+'U5)ZRS$eBE@94T*IGN[U#rlB6M61XT,6B4jL,ZQNii+&dUY#f%%Sil +aPS3Y8r9CTDC49eK5V!9pl@"N'C*U3#UPILI(GFUJZlXKI2K2JRVi6j!!aUKC,QR +6dG,DqrlqBdl&$+46kXiFeh,68+YpDY#+FZh`Dq1%eYI'33DMCVU)4@U"@"FKkfP +*I4Sb'6AEjG&-hDM'b[UlZAEc$dGb+QBJLe+hCEZ+98YPAKqPKSmd#De(QL#E8G0 +Gr84+E8KTj96-3!kP0UA5ZXDB50hPIj46-31jM*T,U5ZaJG4Zbd0Ui"j"$G`$)bP +eEVTVHFLb"[beGGCM`[0Q23DM'$A$9D6@$pLb(Alc5G%0Eci*SbA9#&LQ%@dl3Re +`lhT1a3aF`+KCVQ*Gp4Xebie`Mk1%hpSSY,ke%FB)DNQeETAUQVqkKrVcX-+TQ)' +aM*VU)N2J31Fph(BVTf)'aM&U0RCjp8"TlAe0HF,cQ[,J3U&eMDlY(0$kL'm(Tf) +'aSYqAD[Mi0$(Y9[R2L6kGHj$-)&3PBmbA5Y-BqF')eCE1rc1)G&$lab#LaJeeHA +@!U'"#YfReR!UCQ!LSfC3kR)e0YVBpfej59#h[!3A-qTSEkRI`&%M8)2MbAE,U)r +3lGDTpiZk6VdI*K%Uc-P"HdANCM,+"XrSE8jrJIXVbF"NU[AT,'qa9K@UU8&bVk1 +mpjcSK[HHJca'cI8@QqT1C&CBUR@QMq`I"FCc+QCJ5S6D@b)lI(5"d(Td!9c#U$R +HNX!1h63#G6MS4HHKSqXNG4eF+ZTD%[CTrEjXlhj46$DBJFXB0GZl5Q[!A3B1$Yd +Y4,3q,V8q$P1&9VG@CjJ0CiC34QdmY)T6-3264&dpf+qNbhZiG[MBad,VXBrKFP' +KFNd0k(8pF`e5[E1r`DQBJHQL3Z9D$8j%Z,2SlI,MQiA@ijYKKY"Di6-e,H$"68T +20a`A2S3CZ%*3+l@`9@QUZYAE3mIIPp6hi8T'cI!b,imLUHHPK)6RTB6J+M'r&PU +@kUY9Ura40lHpqIH+EXLr&fDHT[BD#PESe3p%K9lp!2)TGG*SMbH2HQ@K(hFE`A` +cD2VDrIA4PeBVHmSVbSY)"QBaVD0GG%&4V!IV9FYAfcQHf`mri4C6e"0ZQ%fTqh1 +pP5@NLf,l([Xfpj@FLKQB)r`9YbmUERV)L"Meef-(TD-FK,QXVQ1aVN`R@GqK(89 ++fhccRl%ED&da!r2BM%+RqGM33,6qE0K1TC&Ua3aF,DCH-TI(TPG5SIrhFLTQB,k +JHR3I@9r'U,FPlHC8c-!#4XeaHIbU6bXcr$hl&e4iA'Sp$JXC0G0&AGN)pHiFl2$ +EB`6el6'`5&$4+3dr'N-[YA9*2UGL"KB,+ZPa-T[hDAe"DRd"PR"rpAL-UL+r'Ja +U2IkkYkU58c%$e`LYTBB[&1aV2G`Af%,V@cBXTG4YZDibA&rjYGMQaJkhl4,8YPf +`M(P$YUYFVGB0(,0$(D-VTlkl39$Ih3$ALVQm8UhUBe,U38Np#0HaZSkL1p%G@Uc +rl1D'YCb+'5LJe+Bd9k&TUPhl58PpT1a*6X8-&$,U5%EY@b[CYmpTj&6-`(*'c5C +E`(Ue"dRVH[J18GI$Gd!4@4T2h*1jST!$3Uh$"@G2N9V80jjP9*+"BNE02NR&rAI +9'HV,j8SMXAH5JC*1DXG3`kK,$pr*UCL"8NE01%QYlHkK&[83peH5J49LkQfI86V +*1*Qm$l`E-&2'ZK`llh5A4lLi@4XMU*KC5DK`rqM#%Sqa8c0a$JKB&5%G0aAYA$Y +Vf$&1*CRV#e)!KNr+,#cK`h*$Y,$08aS2-#V0V1+EElC,jXYPl(5VSd+[r&*8#$- +ZTM9jDhe2m`MU[JFAFbV*Z"NeSe`,'L(6KriIK8FUG)1BSULjNJNJ5X8TD*'S%'C +@#qT+Ra'JQm!BGDbNMJ@2f1HKPmH-J9"hl5VM9*+j8H`Tb6c%Gl"Rd2EY5bCc+XQ +8XleAG[[HU`[E[2(1E0i0*&2"h#ZV#1eVB(hBSVBp)0bVl3'Sj+jmLYTGfjDP4lr +,UCJ",k111ZA+TVC9lfM!PQ8M$h!UCQ"0`6$XKK%M2Cl0G0p3TURNd+I6mrCqkjZ +m'dKQ,G1D8K2XG3ATbQh5PGYJA8%D30V-9(3l-XchpHYeqrl#YC,-HNBGdE"$MED +FS,EqF5@RNX`'['5"XQ!DEJ"ReUQq',GPbrSMM%Sc0c'Y`d1"cVijAD'@AiN+BHC +QAU'JKB2S3)91eh8MTfle"5cr@@V,8e,V8l#*9bL)Zp#c&IT&frFiP@3fFkUPerA +lC'H&Y["qa@l!dJldDhXhU,bZSEMB#,@+8G0#H(QPpR-M9"rAkV-DkMr9ZZp$@GF +2SCTi`r86FY'pe(TpF`djC0'l,+*PmQpIjqk&'G!B0C94qm5fH2r`AHiS*,09HPk +eAkrkTqI9&+5L+rmZ"kHKS)&1(V4#9EKrkC`fjRq8a5T%-P$,HdK3qh[S%dI4bAA +JKF[6kh4VCY$`EHr&fRYq-S965@BElBEITlT9Af@4TlqZM3GQF#V*E'GDFiA@QD4 +[ZdcGcUlR8a60q-8P%$Rm1hX*e#Df,jL"1NC0TG5"@iV`NIf#HQ3r"1MFF%X@6P( +Xl+jK`D*9h9hqR+)d"Q[p953$"TZLaN5QU+*5Gc[GIQ6V0QKdZi[+D+DHG(RbXjN +V!lMNfBVV3e4mTN,0UhpDJ&V4!NJ'EQ(8A(BYafm2ZmM0`@8ijj%+N3bBK$VX"q- +,EkKBQ6IpDRh@SZSCH8AjV%,j%Qqh[VK!DA4lA+8N!d&+[AbdHbd$PBI`KJ$G15, +AEX8V-8l&+c',9ZM&m@l9UN853`[4RfJpJ*XH4Me`*m#N@PLYj1)I*p!E9KBdiqb +RC"6aEareH38f8SG63+0HV%!ChGJSX)fkN3,EUEmSS&028f!0R@kaRfPr+V#*6Nm ++h%aG@B'Yr(XGrpl-[lI3D85"QrLhbVqVq2F'1PdUX*l1TJU`L9f"YA3Z9U#D6KJ ++P0,YP3*H1TZMAL$@Q0,4$miq38B&rqkSUp"r5ZH`Gr!lSY2Cm-NSjYqN2dMIBIf +6llUVNIrV32*Gpca2qqkFcZK18%B*rpi%@m4INRIr4ZLFRGbdiA@DlpATA"r)Q-Z +r5k&-k[cqhLf`jU6qXcUGk`dCqEdk0hATT$l!,RDP6ZG59!EkFG3(9Y#pjdNIB(f +9h+(6Z5f9JI0R9'H(2Tb@f[Yrm%C'aXcrk)YGlXLi+U(2ZD+9J6IjAqPclRTNc%V +SFqjjC@3-p9rmmPG'jRPpC"Gl5Tpc5bYMC%+IFh8VBp5J2Z(M%Ah1ABQ-krLhQ'2 +r9FG2li"PM%ldLA-a,11#)Ahaff)CBa,kR,XP'GF-q8Mm)Nf'H+rK5hh1&E@-X82 +eLpr'bCLId1GFdFPB-06ImAXl'3Z(p2h$`9RJQaaIkA2Zh@@-'kTIr%C3aZ)KIiT +IhXZi-+(2ZG'A-Ikm2Vb!1Pfrq#jCKRL9jNYpcSCE"RRRjprkR!Y,'8Z(kKGrUd0 +'9N+ImkU(M1ccqSDIeZHmAL0$l-GLqJ*!b--lp$R[h-J3qj19p&C3JH[TEGfjHEq +RRRd[j-J32[UP2ZG9("Q#kqa&)[UFph0NM1$IUqLpilNq%6bZdlR3P9&`[NmLqTa +EAKQ&#Ah1eDq-j3PpcVXi-R)5qT`AG'53!1Z3!-reLAhhbERfdfY['GFQp$Nhk$+ +@RII"L$lRr3-CmrLhLel`R[2"6Tha0lp1dllU`rKV1$)Q*23jlqE)Z#LKchPK4`D +q[jISmrMEC$,%A0bKcmhRa-%k1Qrqb,Jid5I1Lb)bf$YerITZJfrM[p2NABR`fm& +A+@3XiGpLAhi$[6CAB$@p(eI!3br#&EL4hRMhqkASedJGR&H3!'4-kUec1Ed5lqU +RL%lRh53CNmrhDd5Imm+5M,crkR-DC8T#Rr0UNia,%[UFpjeNA*V3jl`%*H1bSIV +&hib5-IAmh0,Chr'hJ'6-kG8AZd2Vl22i+eBbb,ZRArGKr,dV'CF2p@(mC5`Cj!h +2VqXAId0,aS`KII(AYQ4FNG$R[-XPimT"IAK25HmbaEfGQ(X(ljKP"2PhV`lR1Pa +')+l$ZIb@)EUK9iGc#blMPVJ1jcTFKMQSBr$b@iCiYdE-&4%Gc[X(-QViGbfrpil +j!M'GaFPKA1#AiT&*f&2UTjfHI1Q-Kh$Tp'YbJqja"8qpTT0%,TZ62"9DcBN6mNq +ih8QD6[j$&2d2$3d44e13!f&YF'aP,MBiDbj`FQS'1J#3!i!!N!3%%cjd,Si!N"% +@!!!e*J#3"2q3"%e08&*$9dP&!3#X94(2Vl6,K3!!,`X!!$dU!!!,X3!!$UPdMRM +2!*!''Sm0`+dRNp1"A3lNP&011GfXPCh(6cYVC6E+@cHpcGE1R[ZjXPZjDd9[5rJ +4TKQHdr2BQVrACdAV+0QHPmAFE,001Gh[%ClNZ*fEEEV25pT&D1AR'pRdFM1bT9[ +hXH`)ff`rbp)pm'+EE'C4RK*qlJ&K+r"9JrKDPr[BjA8d16dHi8IE(YRR%4lCNX% +QQh$aC!0N`1pR&`!$J"`r`&LmPDU@PCNEiZH+2Ur9iKBe%l5jFc'pjb4GC$DE,E9 +ZKkLG1Qf4eZfa+d!"4U0T[U&X9M',a!"+@RZVdeQh)1PaJ2ba!12MANf1!VKTCF[ +p0eq@d-2"K-T*fSRDLC96HfX0!lK`EF[@+r`a4P1CaP`M1Ka6Tef-p5CU*ac'T3" +)q8E,3cZr0lc%jV3i0+CCKP+[eLYD-$F@&%`k9#N@"2iIV)XS)BZ,j+f6$%SXT%4 +0[9+[#62HUGph&)JL9JB!4I$-*ND'@E5ZaEihUZMT4`Mm"2iAX#B@SlJQ8NH0D+k +!+BS@pJ"dB(`%3-C5r-q&+!Cql#[5mIY$+KX49XLYY`,-m02(8iLCQ#LMbfQaZ[S +B&#!EBPQ(iVV3rk&$D05A`l"%Sm8kckbKeM$(jP`NHPj&%UKJ-KPHUj!!AQ!bc6N +YZ3Um#paZKc`!$U0a6Z&!RB3jYNV0V&Uhbq-MDSr@-*VQP-J%i#Jc&-N$m$VI22m +B`2GaP"DAPbUeP69@5P$mm5iZmmGq9ijh)SBmF-kZ(kN+,3k(bqA8c"3GELVcSYq +2qAT)@,*ED0!3$)j$SH8S6Kb9X8aM''r)b6QK$JQ(S,AQj-J#i&"UV5F*H3m(d5i +2`+Zl$mLl1-5kNi6mr8KkVIQIAUP"5$MkfBK((#B,HP4dNmH*PAKe@lab!6LXIF` +1m%S'LA"%%Bih1Y%T(!VYUciTFT6caD[IdD[hC*q13KS+[,@m6r-bIqh6jBCjJci +QNBU8p$ZC+TGemFFYL2X2MpI6EaU'F(KV(*8$G4*-a@qbLMKmLf8#F("pDP%PrqA +94&SFm13b))iEU6eDi`2(I3+(E)$MRPFi@c2)"mhAhZ4$lX1j(fIe!qIHMq0Gjck +)BmLj$r)kj0`(F-J[12GMI2cEZCmJpRhR2S"Mb,NIJr'KFqr()4rJh!8FS&I2hAS +GX*p["YA#LKVrbhT'mG41$F4Yq4TdX+bQZUfY%,-+bAQHqaA-Ep@[U,L2UFC1TVM +mKq-q,[`2(2IV(9Bf`('AfCb6*QVUTNepcA((rXXa)C!!NjhKP'2Uar'ZdaRNBmM +T$1!ieFQ2iIL`NrIM8'VlZeidiN$K$eVcdadQM-0KkfYlVd`fAPFDiA"9f[Y`c+Z +d$q#)-4jIj`L*`fLB+3Y!qYZcKQKNJb[k64cBU4apRM1*F$JXAUr'i+Tefab(f3e +f"P5dH+8X!+qR1d2BNrGlqe-i"MV`J-l#RG2A*l1K%cFCYmA-Z*N9c9Tak8Y(18c +j9#-NI+NHG[f3!')2-191bASN,,YFbYp*KSa"p#BqHF-D6C!!F!2IP-2B6Pi[iI2 +SS*rThCi,eAqUAD*kNbB,@bA@5`c@IqmJr[CGJISQUSqiR[YRrA0[q,Tqp3XQ5-R +&l6VL"6HZQ&+RdhNUTfJQMCm`IIcd#h9iY8*klB13!$S*D$iJG0l@$ZRQ6MMEY%U +ijE`(*5cAEKFkeaB*0pIQBM3jJ,"!k&bp&qYec`4"m'prQME9BM#(c`ApffpF"AN +ch*F865UL10A(I,kNjZrmIBJQV+H(kZ+pN!#bF3qKjI(dXJa)f4r0DS5G'+rJF@P +2MGH(T"a88ikdrGDjfJhT9q#pd#haYhVM(FZa9[)6HAFX&qSh03Re29MhN!!'iP% +$ZPUEl`+[blT)PaAYlrM#Tr`G+qVaASYPP-)cjb9L,-2ImH@$H$r*1H[3U2dG6b# +@d,UFK'RcJ9CKmfr,r4f2ZiA'2l8,6kje8`l@DS5SAqE#clcY`ZCR-HIC06"mETf +%j5FBlc,jD4F2eUJ!ePBF*)dU4L4LRGf+kV44U&qNL[BLchF+MBrbQ5Pe4kbl!r6 +a@jAhA[m5aprBQ8hj`Sh$1$CKjFKGT&KKmh2P@'XE3*SHDk6KVF&EMAF'D`0fCN3 +$0UI9XEK+e0NUMq4SI"j4e"PRPHV31aj*ErZf6eK93eS-pi@fEfB)EFfjNEl3eU` +2pi9VfN0p!HXIl3YYcGI"ClBm!LRIElKq'Smh3AVeEC!!mZHlX#qdBBN[3Y,bEFd +H)2XMB2iDripEIK(U#fh0h@"j14A5AGfm,l3eKm!K2fNS,X8%RE6QB&lX*UHU-lN +q+hT-$SX63bD0b50D*3YAKB0X5jASmC*r8,#UpEQJAV!ElqemSPDeIJb4"qScaf( +X!0k*N!#mY"55QYZcN!!BM'Z!MIY0U$&AV6G*mA%qPV0PMGIUXF&Cf"ba2Yr"V,S +(64$b`qY(Breefd#G&YkIc2V+[IUElL29F*q"pHi"pERV@2j2Qc#f!r%emIkIe&` +[e8FqU,jkC($%NJBMq4EX,P#N[kk"R#h0,'r*(LUSAl(a)0d5aPBIhYNXr`(-60N +4j,33SP@JbP5(H&)A8#IU0bN"I&!9`%&al(Q%Kq8rrYD'bA2JK323bI+[MUBHJ[` +h%#GBAr*EUP%0N!"dbefN!ml(l8c2lj!!$NJ$B`jT)+Mf"8lE9IL2iq0J"YG!AP% +LXjipQ9R6pV#m%GKKeAa5bUbTLIr4J1jANXZb"R"3R$5!H&MHc*!!HaR830l-09` +$eV0`DU*'IP)P[4r@`)2X6(j(0($"DaS`,r(ka&T0FCh2Br''G-#+[Y2%l0dq[,1 +Ci58drmQ2F1lXA4reJF+($[#!2B#$iU3"a-1+eYhf$`d8E9M10@$IKhdJq4'XIk` +22-b5q"h@!2F$f5D2bbjDI4Uccq+cZCbLCmNBhC'FN!"+j#(m!-ZrC,qFJ"miqe! +I`)'Jaq+aLDKjmJ-"RBEmJ,a#(bKZ5(Z[$e5mh3Gq`+Ea1p)(KKr5!%dHp)KP,qS +ZS40eP"dQ,+4M"@,Xl32fVR!IX(FG`,Zh$pLlH[X!FRbb$pMhpIB"cNH2,mcm`l* +)(l$[NrS!eqLq(BL[Y`m3(dIl!*+T`TFHiX`fHNG#8bL+TlH(C$X1cQ$BN6F`j&Q +11[MU4ZLR%mUFdm1Bj#A!'5BER5"QEkF@3!2M)Qb3IJVr)kc9,qkBT$H@lj3$ +)R)%R&,`8I'`4DqGXSG1iFaB&8Y!e4-jNR#",Y#H(bA4la#YYG8F'jb(fqGXP2AN +lT1jkZ*EmceQid1ZcH2SH5T&"1&-JjL0"U`i99)05)E93&RQ94QUdP%'rf&Ejl&M +f3cC-cCr[ND-j$p2`SYFf'E6h(bT#0NDb4B`'!hM6Jd$Pd[+*c)&XH`c8hjiEdR, +63qp1R3)Nb-Ei)%NaN5HZHTrr%UBV5Mp"#XpJGi1#$#KN3,Vl8PScBeHC5qGRi[m +bjI0K5%)VfR+bjRL+[JZdGc@+BK8C312,f46lA$h3S`Gmb@5'!5l"hrd8Lpq*cdE +K%)jL-8Q!$c@`bbKQdq+B$9JMa4+[!P`m`G%KRR0'`l8!UAN8QhFli&Ea5'i[TMi +-AmAje(++6Im@h)%a2Y)GeJ)iPXZmQf,AES+0'10M[m`li9(FFq$e5TB"VJCNmEc +,kq&CM$h'-GA$APb1DDEBa@2K,aKlQQ*eh3`ADXl[SPMC8SBM`p(FBe`mNH%iER3 ++a6kYBMKU(rd8a6kjK5&If5pbI63b(*f2f8#a#@PX!FCqc8A8552!X5m%*(81kBm +#bQkHaaG,iU9pd$+,afPc9UZ#3f1Mc@XG(JbL6,di38lJ+jqK"F%i@[SeZ+V%Ld4 +RE(J"Q+F&+LF%%8Kcq+ML+T[2j4&+A%jI9+R&8bhk9!9@UiKEKbD,V`EcHCNiHVm +M!#b4BN8f,fiQLV@9L$Sfr,J(Va0%+Y%Bj#B3$V$UM6+8',(Bm-"@IE"+-"iX%dG +2G3@"8b`#22b1eaN8`L9VALp!J%Tk6JD*G)S1&@kkKe$q(`#3!`h!H*VA1HhNMM, +2HLm[dr,cmT[3@ICV+DFQGp#CKkH'CjlXeM5qRM%Y`MT#)j[`)j[XJ4IKC&0bM2! +M2)pXGQ36IQ462,11mS[`5AU%Af5`b@dMQffffIEp[2+5F20,)cc*l5HF(!0Za#l +DfZI!XP[$EjD%dddf'A$#)lm55LBmXXN')U[!+eD0FZQk"`!8r"d2F2-Vq,XIBhE +mMFHr(B&NZ"lLB(a+RXrRFEY8`kel6k)8ejqZc@dX[ZpY,Z44aF8K$f"UFS&H@kY +kUc4rB1XPAQ+aTKT"[aDB2@ZVq'qR"#r"VRUeJ0I)R[-9,khBlG'bTf3l$,qQePl +NTC*mDpP&'c@[%IJbI`NfGm!JqCMl96k'1B)qRqihXZGpa8Yb'Qk2fh"VJ5pjFFL +cZ5[pU[m5$cpJ+ZcBGS,piHp2aSGHr!&!`TKH(X$[b%G4%$mfBqmB!NSZGSZiCj* +YH5l5)A*F[LkhCZM0SmU@LU)9&53#FC5kIELY9+r52)9Z[qBbG(mlh'bCFT*6-3* +$'$@$8FXUeb2eV''cCFkVJMVR9BK[p@Vhkcl0Ep4hH!hY6a)CfTm%#5+[6Qq9VR@ +N4P,ImJMU@aiBbVb1F0)Q`RT)DA8l(4hH+,hH#--BGD5c+'6i9CG4l0GVmiS+YB# +V&B`XA9*e5+68lfAB6MIScQS)(IK)8!pm"%Q-QQD6EESVYHD1Icc"U4L"C%UYbl$ +Pqh@ebU8'M#kZ'ATlY2$kpQK)BG48'fQ4QMG54FMD*DQl)*94dfefcHr@Uc#cRNk +ZfI56iCb+%8LMe2ATYN,98&Q[lk+'$M8+ViFD)Ce4NfhRL*4DRp$#U4L"$%TY6+4 +jM6#4ZXRc(+GL"$)C0C05&f-"UCdY$kRH4`69q`J-Tp6CbEEmS'(dpGH@QFq,RMI +cH4M"U#Qf!YAAejE0d,X[L@TipbA)NP6GDrMeVV)Me+HfVq48M-"PM*TQ+h5V(Vd +kA`peGj63HkZ&erG@`dK",DTb'm9Zc9296AdbT(!U4Q!8SbEDb"$B9hP2(lk28c% +#SaNe(DZmULqejSl'E0(c'V0KM2"kKeZVkr2kV'XMTf)%aSTkAHl'`D'ADlE-hLR +UGIC1'%HSbQHTYN9q[@k9(XQY'ITJRkLK$rE"jBbDD#[9[-'q$$fQ9R-U4Q!mSkC +3DViD'@h-apDq)DKVhi!V'$A,@Hc4FG6`9Z0iXX(3I@'kf6*jQmMVj'd`J9"K9JD +f9d5Z)D0Xi+cITZ5p[,q5#%bNARHP13ZebQ"e0C*l1XU(ViYUq2"eb'E86'HKAke +$TX03ME0eC$lZ(FZT')&*B@T2LXc3dAR#kp&jF#@MCML,["[GIYeELi0HecadG)@ +NVS#V4&k,3LlYA&mf0rp46$BBJDXC0Gfj9+[(A3B1$TdP4,bq),fq!*1&ee+Y9[I +ARae#'E9Khe*1a3K-%AQeBlf5+ZrQQU&MR`Z[ack(Dd5'bMA9kklYRQZ3!1UmrPj +1a3K-&4NUekTa)X+G48q9(emM["jI!p1%9iI,VfPH1fj5ZU[KZ1K$')&V"E9##aN +9IY9Yp063mBmPp@1BcUJT6YE,Zj!!Y1FP"%A25`M#G@*qc6--e9@M9RUkZVRTc(P +89%21Sc$M$,@RS@#'$Ti3'6Ti!R)SG8+@hCj0Hf@H"hFEJ4ar`1pUlDr2[9'QE#P +hP"H3!!M-C&kcE(4"8HJ1q&6$9G-qRTY2[eJUTUJA5q&k5RdQdeP44+SSXZma(bL +GcUNBJ9QL[q,f4F90$aN4ZrVVX6fbSqb"f5b[Sc#[c#GChf%l#UHfkDkrB$A3[') +%jV!CK8lcND'"H2hCN!!kTB&ka3MF)+CH-TG(TPH5S6ml148M-&G3l@iA@9p'U!r +%EHC8M-!m4Xf`f6fU5b[42Ghl&h4iA(Sp$MFbDUU0GQ8pf,0c-%2[Ma68pdI#I%( +&6UPlX$(d8&X@jR!U4Q#"S*)D*l0jVpHpdZYH@-MlUpfZ9aCie%"!kqk[fbXV1"8 +MF*2`@UblJS(HdX0pJ5Qm[QI#cC5k2Y0@JZXVMaECh*LK`jX%pI!QZ)AeKR4EZ9V +PeR(-$VD0VTakC*@J(PN&YiUj[%+Yl'95kKj*h31hXEb1S$[4M9UNrXbQqZ@FLK( +)TG6'*&ZHhkpfl#FPpGQ5PcJ9)j!!akM$'E9hV@3q1+Z"8c%#qBbD6VD!2V8E5I0 +ki#'4e`-233(ZLf(mPY4&$SG$VF8&ChH5QRG@Cc%UL8!KSkDISZ,qZr)XYHSeTB' +dGa+"SRCUfe$$U-BB&kGL")SC0Dd!XAd,Q1DG03G%KQS1`+,F4+b'AfHiG'p!4kF +")eL*rDZ0fM6hXc4'*4%S%4Y(FQ"`IZ0i@&3j4Q!aSbC5DYr1*R6S'8%pp!`X)6F +CBh+c5TIRe,U0'3(GY5&Rh[`014jhDb%eVcmbA@NSYGZ+535@iRiH5Zj*4NTe))$ +!T9eHQjfrqC!!8c%#0P)0mAmE9kSD0AK,J06XBRAU$HkCkfE1VjU@JhrKFm0ZR&% +)P85JP&,h*C@UVM*(@ekqQ$CfEjA8VE#-8UmFNlI-XCLC,#BQ#dLZT&0#2B(6"U1 +Hf!YPY&ir65Z`Hi)"mY[YefajCCQJ[V)-l)5DN!"f@9i4ZacJGaMS-NFr6GeqErT +ZTD%XIdNfLF$YV+1-10fpr0SkGbLR*Yb(VZ1GNN5J2"FV,flBF,Yp$Ch,5c59(-5 +%S6J2hImGi2-34Kb-1L*-EDYEmpQPVd&$D@P"#Be8X!`PN!!5$rYVcC!!ZZm`ca" +'`*QE"*!!0#-4&bpN9)k!cGYfr*9RL%6ZB04Kp4Y9h*,eZM9ErV#B8dPN1HP$5mC +PBSC8RhY006N&F,[DmFd6Ir81ca"'B!@M*M*UVpPQjqprb,c5b%VDm`**Z-ZE8DY +fQ"68Y5X2F5U*V'*j(4VdYPIfQ@TSrU@S"ScFbDXKB1")f9F0CfVS,NjGjr)DR[2 +8jTHPejGK0Fp3!,HDjc2dmm-rjP35ZCY6$AHYGL'[V4PD`hX$9J1QYUmhY&E$@Tl +AB04XQ+SbDP)3EkM8Fp``YC*lG4Re[JYHGh`LmrS*Z&LR6$R9bl[)c9ZqrbR[3aL +"+MledTPb-CdT1l(0@a`"3A8%3'-l!*c,cq`!fLD!d,XMHBC)C"fGmr+6jC!!eje +DFmY2*h%UL9666[RE4*bp+JVXjqUeBIFd6L@4'ZBe8hLG3@UTSkQEkEjd6L84YpJ +3YqlcfLhM&ZpMN9H-V#G8f*D99f6Akc3rEVqm1(qjF6rI5ME6KKcM9",CN!#E!$" +d3QTH%9m4ehIPYQP5`fj'T4%2[rGL&e6mT!Vh'dCEK[Er3Q3))lA-Dr`khrNK#Qp +%RPV!U56LCG58FLfJ"rfZXqA6Q5&Gl!lT5SRX[EUSZ2ZE,c+%%CqJ,XBp"EerL9" +(5HSSZ%GFXH!'+p,`#(A6TK*1*4'rZ-iK@d"qHA3@E6kiF#+RNNL!AAZNYejlG'# +E9[q)Ga3D-IJ%),B[jbD!,qDK)0m2NDjFL1Y$ZM$[310qTdaZHXTJSlKqFf##2"U +#Hfi1$MiZYLm((iFk4KeK3elIX4fb&NMU!JJaDLUKX[4dl`kE(Q[N9)a!2FYV4QY +H1m#Bc4DCeaEB*+Ij+Pb&r'ZDKq`hS8,*a$q1ShI!9(%dBZhiT!ViGb@GX"5iLeD +R!L[S0+k!4ZFD"DVTc+&!$CdL&&K(*aF&bZRQ3`%(h@8SX*V1V3VF561NJ*0rhmf +rep$j6i&9r(XYreEjpdSkcbY`"pdm+"#NGDp!&Ch+&'$E$`@@daf$!LikibP`1ph +EB&j`,X)e89Xp@"Y&U@,qhCCAiCrl9)BUZ)f#X@dqVEUAUZq[Zm&kfr3r%qVZG,d +0q3#r`h9JEBZP#NAG,GU&(l[L(plm42c$pjrB!)$epHJlmAJ$!(%(UlldfE9IPLV +keUGeb5)eqeZIeL@3!&61[hh5IXLZ[dreUIkVBbR5j6VlSC[Z"8leJEYK,9,Lfha +DGmT512pdqHchCmed8R8aIpEd*a@+qE-Q@DQ0!rj`Np6D(r[[dD4QI1X[FL8RG9h +-Rh@a,T8FmfIGd%R0M2QcEZHP8JEV,hTP,j8ki)pXJ%llXql@TBE(r&NAlP)Mq[f +*15IXclVKNVU0IiYpahrbH1(QALSV9LI@GEl8CB2qSRIm8L0MrU`E3DQE"[Y)p2T +6kSDB2q[&!UP4JrQ,hU&+cBhjXbj@THB0eRIdYPAUaN&rrqcJ620MrUbh*D4'$qB +[HSmVY@#`2d9IZC!!%Qm$I6-(APUHSXB1q-1lLc2jLpj65Lf1qE1Z2+9+B[kXDfD +TQ`Ic&hdA4bSYjXpk38FUIF$Id$2qV*HLT-4q,1,2#i3mY-fIpDD8P0LIV+FA5JT +XS"Fp&qIplRcf[NBP*IVSerkX&kLN"0IDLi6p@@p953hMhajkCA@a6J52ql5ZiD9 +b"qSNl-qkQjI+LrQc,ZbPmQ2qV$HST$*LrUcAUU6)&G%PIq)Hi04FHq&P"DPEBrk +XpakNEKRSJf&rePXM8R2iGbfp'lcB"pYp4YrANa,h)0r8BI6P+DPa-Ar@'e95PmI +m@DpC5H&EPl%kMli$+#AQiMCrAMiRpZI4HPp,kSTBR9L[pdL4YbI2qhX![S[r6T* +h0k,IpVm!)l@3!(q,IEP1Ee`9m0'V93AZSAHS#[MTCHQjILRU0C`(km8aU3NpH3l +3fp51HJVlY0iSNjSi8+pKIpCVCP,Crr9R&FUNQ$rVK65T+f2qV,I8T+k+qE0HAC1 +kHM"rdIICT#B2c#hYp4epGdYU9Sqrb*eHHje(Aib6QM*BKp'hjD5Z'Dc$k#Yd8P- +(maGpVdjUfU#rk-Yf8YI'r&P[i%P0lrGA$#AdEPAFfh&reUXm8Z4pDU)H(pEl3e+ +P84r@Ld45bk)qV$H+T-UL2UbARk5@4(eBEd&*LEq,Z5,X`hSV5fS4rcEiIIVAIF& +kK8V+GLS8[b!HAcD2`d[mX5rELcd"pTm%["3IMpF"f@rDEB(6Ei(%iImJcZl3UNq +HP(r#,9(F92)IXNrl2`d0&8G6N!0KEA"XC5j`F'-ZBfCY,R"bDJ#!!*!%""-qG1# +e!*!3'P`!!%YS!*!%rj!%68e38N0A588"!+a9%Fq[Y-Yb!!![#`!!+9i!!![*!!! ++#Gp'&kJ!N!B+-3h!V5H6di&XC3jN&de1&aDHTEe&Z5Zc3@mVSHA+EZf+9QaPYh, +A1Sm``Nd0Rmccf*UrefHGedQfpTCZBjY&HHF4RZ6BEADE46IC*UdMP&pq[RAd10f +-E1R@IH`l`MEEcljd$eLa6EL@TB5ICFG@i+X'FITe(EZmMLDRab2m[1f4I4lKN5h +jI@56KH(*"PJ01+""GJ%`!-J,!jb0AkfZlXC"prDH+SH#NX-[Lb10q92aHZ[THj( +GERG8qcfbdHqAM0,FDU-ri0D!"Ua@fh4,DI6rj#,Lj8jX4kHcGNED*S"KP`'-5(R +pFJ,!,6I@2A$V,(fV"L-V4KY('8G9R0H1e3[Jr$9e'fH(Nkbf8Y&H*AXmjihp$1+ +0-Sima%X$N!"a4ph$fllACj,,kr#)YXQ@NU!a+$[`EM*SQ())+4N%rMq+Lb`KKj[ +NhC-1@J65SUGH`k["'qrMGai0XNK@!@!424H6)VdF4Yrmd0XSC[SM42j%rXpJ05a +*Fe8EMJ(Cc)Cc0AAX3@M#qJ#!l'[`IciN-!KMAe&11"acfB#i3fkr(@"mQ(lm#LQ +6P'$eH4f5Ve0"!A)KQ69T&XIqGaaLBlJ8HU9D(G)dZfLc@F3T,Zmm1I!kNak%V!N +ffj46PL[(l`5rhk-1`-0UR6+a'dFra98K6Ulfq`)KN[B`KY8fCC*+!)p55k%kJ+l +6lG12%2b)4dP4@BR@@&%Pd3A0+hGbQcraZc,mTQ)T!'IXq*&ZSX2MmIQmBV(Xm42 +-Lq%`hMH$IZ&1BDP)0$J2MC'c1(CdeP,4-X+5PhI-(3S2`5MPjDN#m0!DTH1#I-L +$C&F(d0AI5H3$([+#ii,mp5KqVIU[AkP"+$bke1L02'`1c+LB*Sm+UqMUG`69!RK +)RFTfkdS"LAJN%)qh1p&*(KVMkcQTl@LRbeHqlpIJm6kGJ$*-#&Ec2XeKrYbRbbc +6HR*-+S&-kNSb6TmdrrpE%-mIJ@#J+c5Fi"'XmP4diqKY4HqSLMa#me8#H("r'Y% +Prp(94Pj8%MH0De4,%MG+HaMMim4pM)GU31+H0[&LX8F2QUqpSiID4h)rUZV(bEf +,a`I*[BI(LH6HSqZ*j0l03hdKZ4r4ijr*rCL`(bAhEKiRN[X4'TmNpbiHkJ(*AF! +"HZA8MBZ"rA`pk1D89i9I0M1UpfX@)@A$9k'*jG3Xf&J25FY3R1GjAX(lpHBEbZp +RZV2(8&hp)h%I0Il(LIZY$UXDN!#i5ehHdD2%"@22Hc0a*rmM-5'4ijhKC',Ui[& +"dZR4id65kHCaXT-IiI&**qrLS69fGEe%j)('liRQTcT-R)I(eGRfATYX[18diZ' +VF(IbQ&EKlZD4C$fkcK%cKp95V!SJqRZcKN48Jc[k(4lBU6bGQ610H(JF`D"Sm9A +lACj$kNBl!cTDRUX+S1ZTcK$2j&hCrL52lJlFlE0ij`aefZc%54Q$ff*fh-a+C2@ +ip'@L1dblI6RS[l3)G[b3!'S2-Zdf*AVSVle8ZEq0!KQ$a-Iij!daDN"rIAfNYSh +Mk6q2#ISCILIHp+,ifaX9U4m6Fl"9)PjU&2r$Jr`EGd6`EB52[*lp1rkCehrG[2) +&'f6NihBGkB)E9bcG4'GHS1*FFI5)N4H-Z1"m8ceN96m%r8B$c3H%jK@0N!"PEiE +qYQA#EB-I8VKF[89SAP-Sh&UGMpAd#--*3[2+2BLhVaJ%)EcPDGT85m)lI#iBhR, +6-LJBllqNF(3Ke3NIlr-PYA$cFc'C%-m-P89l)'2GEQ,,keQPfC!!X6q493REX&l +1kmUH'XH(Y$ad8jkbrGDmdJpCXr%lakrSYh,GUL@)PIjN`DSP`U,(DS4&V9ahN`G +56+CU9fKid#I0-dQ+ik3XAKTYZ@)6I03LM&CiCR)Uel($6c3Iaqa6AV%NdK*Z +H4#kaG6Q&drS$pF,khjD&QcEjKH9rD"5H@Z1R1iLe("*qQ3mr#cB+khIKR9fVSFr +8"3UARf#pa4DQA6aBV30B8hk3!$bU'C!!LMJl0C@CCk&r85VDLacL&CBrcQHQe"d +4GbZBHfr8hRIG5jcrmZCFZLrFe)Yc%fiFZ)-F+karYJba0J0NQK%M%lmLIJhic@B +0S#R',P$UVDkUV"!,KJFAHUAK&iTfkc5EUD4+&Vhb&D*eFSPB-GrPFBUKJ#bEX'c +#l"JhMXXVHHBlC92$Yd,#XLVbBV`[0(`M@fLSc@rV#`fejRKIZ+SaeKF3rh"ID+K +G$*rGm#KNI(rTG@0j[3Db+PG!aUYhBPpS3)J[3YU5cE8"S2JMi2h9i4rAr5,@&aT +Upi(MjAk3!1AEarY#3ff-(1U6LHE5M$3TD`lfqAj+ULDEl`SjB2-i[&LbLED!,#N +4cSQ$E)G6$J3T2fLBmqjm--cBLGmYI+,Q[(XBL3H'[ZGJl3"q8b(pQK*)Ufh-3@' +`,J)ljcHaaZbmfkE8c`Qa[!fVJe,!"DGMFd4m[S2T[!G$%1V$m4-4IqeQ-'6'pbG +c[RbIqCElb68mCb$H2@!iFbdEpp-DV'e&IM@mrkI9,P,`83r#0`b-MPJbB5$IJYd +"QUbh2*!!Yk'@&5cF6B$Q'pBGT+r#X6k%he`flN'mQE%eUZP%505"ET!!)DD6B3* +eSUk3!",K"mi)$kTMcb-qE0bQGcG-RS8J()"Q0Zl+41SKU2p5dJ6aPEbP1fXTT0e +f*rQ!kr%eCZEIQ!r)!m-k2""eq`b[kh,mMq2Mk!hZJB,#9#Ee(m1Nc0fXB!"f@!1 +IP$+TAqUr2'$kPC+bT!J2UT-(N!!2+bL1TCFH$a38VqBHN!"1akQ*!IATTrMpN!! +((Q*pqEI0!m2Ip)"pB6!N9iY&#d)"4c$Q!eEil4VQhKI#Ebkc[)6K2re4VTfljG- +q-2(K!lcJM[#J1RN!qE$#Y5[qjS(#HjG`$lMhBKp)Ia6aMr5"4eJDrmBp`20!VLh +JFmY55,5((#'AcbX(&Jic[A%RjK*eL$c!aPfbAddJ$r6[k!-i%!`i!LiC28pj)1, +6@"j39qJ$48Xc2q`$jHreJ4q`XIcEeJIkG(L!*JpQj,)(IDG[4KrPaJ@,q9L$(0[ +lJ,XPhJIF,3I`fpi(h#hYI3!e2Yi(h([Eq`$ASc8A$[VpY@ep`,eAk32FShZh)Vr +f2N"k(1i$++B1AhT)XE[S(3PaSLbIfKj5l6JiJf&[[)'KcR)-m9FhfTl+51C2DH# +Ahp,$D@3CINHjXCjH$-%0i5+RUr-KLkic(SqbEmS@Pqe8!a#6q-5+-b(%jV&'VKB +QM@p1jKSIHUeL$%k3!"AKdeXI@!R)Fed,hKLFap6REjHdhYZUG0G$@1SrCmkFB-J +4q(Gr838ijd,5TiE@G3!D3+Y4@LKVHj9'DE4dJrjL@q@cBp82fc!$Ilj(MHBm3X1 +,hQe219Q-$h5!["D,)T%&"jYPb[+*bS&Y@`28AjiE-[,33fp1R53NU-EN)-8aE8p +FY6rr*9`JQ2q2(*l0lJ)0"9$)KLcr6&ScBjIE5kB2`[rADTq28a,U-CC60-G6q"f +J[DZcU&DH$65q[*KUReX%p1J"Ac)CEi&,m1pqU[Ar,MiEK8-iUPha+Z"$$@`@e8U ++FF`'E$R9%[m%Z(L#Sd-mJl2JDS"q"93EH62J9[&!(LrQh3&I`IR8%UTCRi09@1- +MAGmN`,(FS,XipLZ`$QYml(I9IRJFpa`iAP%fi'T!$VmRMi&G@(Z#DV0FX!HABfU +T*YA"(l(f009'AmC`S@C)#p@'lQ%i-Kc+-mE-&3c(F8-cU#EQ-"be$ph1HEF`e#[ +h4BiaK1(SI0Lp9$ZMP-h!fUqjLCTT"(Mf#a&,R8(qSi*f(lr(&dYk+rZJTBk!eq@ +Ye%@(aPCA81S6,D*0JcK"e[19cpL#B!SYr9Tm6[NLfCXFA`$Qeb,)qLJ$C3kI31- +8Ad#Bj21'%NSFJ8SjT*XJ56*Z(GSFS5Umcf&5k2f1#,&8UK@kJVLC+&GA)1[Nq1- +H(#I+9*%aUNfN(&%eQ'#CC%@`2T'YqLK+Y"k&5D'RZU,%UGC'22k1efP8`L9VMKF +43+Fm*i0#HQ@2$MIGBbcr"`!!$F$d1RZ[Xe'dblaqj3-["fR[F6m[HcVaf1Gkl&C +#cFeZ-l)Pl2$8m*ZfE[&8+F&Rl0BLE%XS*`0'CTYYmTZ4ii3Ii6djITdG1BVRpV6 +)mCIF0X)MQm`BfFF))cbf@HDj26FMl2,NH@56fq6f%dk1!GF$(ih3hS'G*ClK+F! +qh5b#RJe%U-"iV2U8*R4G!i!#r$XIB0(I!4C2a9S8ril(cbj##Db!3TJrZEUe98X +Q&$1TTkkJ#K+I,UNk&(VqM#[Nf5SX4"iD+DR9@eU89*0UT&qmcCX88K8cBkMTLT8 +[dVH$)Pj49%QTkC3CU,c$+`dP06@`-"!c$99Tq5p[LZLh'JMZ890QqT[q&B@6D92 +dBp@GINb-C9TEGF--V,l$+ikE55eT*YAd0la#j)@6MBCLh1EK$eL%[i42V2hVRq- +26RJFS2+a%4l!(m@2B!Crl-IG-3i+UR"E!*5%Ua0L3j3R@R0ZVHbI,a@md"$FhL! +U81K3Ci3MHT1Ue5800@(U4KrFkPaiaD9L"FBje'N1G@[M$j!!1Q$BkUcmN!#SP4r +#q&k[880[93fcVGpVpZ0LkY$(a9"%IBfRQR5e[c9-2D84pC3'%acUc,Lp4*`G%QR +ZSk2$0Hae$8adU'AaB0BdP)3C-[5@kQ#GQNldJT'P-e@(56309aIdi$4N6hp"e00 +I3,&$,3hcQXkeeRVMhcphU9L"%[*DBqK+8d**QcQZP6dcKlbHQ316(HU8X&L4DLS +r4FMkJ+NI`"5(1M8F9BfNhS5Ge3Dj9XG2ClK8V%!T8HX88h&fIBkD2AZ)[*ip"&0 +TbQm5E@TE8DG,a3T-FkL6l,lQQ8MGTlhM8V%#dahUG*Zk#3G)'9aj5%fp40685c# +$1P56-Fh4rGUjr&hDHF[IKCN1GA+i9QNGAFY@pV1M0!fI(B9C6096TU(RaNj3Irh +DGedU9Z!ZfLKe58A6Qf[dl0"'bCjlPVbHHaE+L"TX5TUKT+Se$9&rP5e`U9L"f64 +jiK%i1RP[G6h[8V%#FfJha-bQdGCDEa`+d-il&)#lbHYhNZVH8Dp(%RYF+PCJ,Xh +VYL3q(%Di9QI&Qc5[&@r#2E3T0aMkhKek[VG@pX*(0%-A2S*je+')QXU-GZJ9TGQ +PBJAQdj3,DSf5IpTBVq`k5G4G*q&HKcSV(Y*dI'UNQ[&jmTbTYekR@jd,AU@q,RJ +9lR2I$EKH%EP62'A6!hil5Nkiqe98i(jh0m6Ve-C-Fc15KcI+jmGS'Mir"J&h[mE +V$'8[-Q1QBJl-NI@ce&bALK9ii$TeZ%9@pY*UmRTT06cSpM8H61e*'RUU"4pkZII +3THe-h3i289q$fB4kFbpEqrp%,aZX`-2ZpST[9Y[`PS%2Km%4%PlIBkr[`3,b'P& +EG+0Yi"(U80XrfZa5X3),UDp4R&Faj80F+h[jDr*kq@YiK$T8VbUTC-[3Z`DTm48 +rG+PBJ8A8SAUe'9p%H,-BR[,ZRH5eHbFX*UqaK+'UU5KH8SDQSC[f%&CJ#9%Ee+c +CB#K*FhL'ZVpNkTH`e0f8F@HAjj!!pXiVbY$1+mV!Sr6DU$C0*E&EDG4bfpb+Plp +-de$q-Lbl4KeH+0LK6lkL$Rhb&C5l@cND$GLlXPV$fdDkh%JELGlpqXl*V38[e-I +UDd8&PV[8X(fJU%ZQ@a8cXE[[H@kppAk%AP([4f!&EFU'S*LLr,h(1K"CkP+a!LZ +*LYFA"5mpiSQBfkqAMr0'13i9$R8fpYAa+FjhZ)kZYlEMHhr$DE$lLK@S[2UDccm +DK0GIMYYEd'jla3Sm4ZmKm5l2[ej&KriDGkPBJ99%M5B6iRbCTaiSh1p5X3+VkBi +5eC5%ZP(AKZi[k,#E[AE$'RSGfPYCc`cI(+cXq6+LRLq$aiQ+Qe,AF$%-8c[APEY +8V-"DSSSC&frc%DmRf1X*@1GZVfK8Ekc9P(4D(GU[Vc8fZ&5X`"2N0D3R-ZQ4dF0 +lJ89HceQ`RZiS'r&mTDRjbif9lGT(e+jpm#6YehUP+DRM-cYciqRU8LrZ)1V&(I! +86i251-+dUFHCHKbHGUJclC[S(M8rIeC(fcDALK@SUTTNHpf8`LIHph%pi#&h`'[ +(ePp8&E5Rc8bMU%#e3jhZA%2Gfh)rZ52pj'q4ZPYV&"@SFDK6)pYUkc2id'Y4b`I +G@Tfr19r3(SQ'3k)#Y8jILm29KU(dAe#CHQ6M8EH[@)%kZVrDe*($Pr@MPHdZ&5X +3T(R&1f@V-S5d*qrd3CUmd`FKK"GY-8-EBV'BdS)Rf+%Q(9BqrEe$&4ABi&#RpP" +aL[URiE"bUVkJA6a!4!8fpP&[2,XFk[V62hDT@)&0$V@d&V'M*k,$5YIVe+'Zeq% +CGekVYm3f"@V,Sp(DSANp-Ur#R9HX`'D(1M'LQ,Z(PSQc'rj`J(B$9L$X8+FPp&4 +Dakk+9B2E[)qkkKqP6SG%"5*fNJ4Q4ED9Yb60C@NpmCcG*ZfDlm1lG[c1kC!!U-! +@QR)4d[#ZYPfd+E%#@qRZ*DLMGkrXfEH*H[CY6,D-XbF2"mq*5,4KI`BQ,hiXiNb +$U1"9rL+53rKKJG0KS8+l)VF-5p$TGjm,Z3PBQmM&Z![p,Z6ZBQhieN9ZPl%fHLl +NUje9iEQ3!$F09RR[G$NT&ABKda%XHqIPAFLd"+Ziei@pEkj1epKYKlAXYS[mABR +eU1G#*MPB*Ci,H8&L,IGFb(`)Dl)r&hjHK$@PeiApNZKa)A-@V"QH#jQlB-hdA-M +l!H[TX9lF5R1`CRNZC,U$GCI[`NplX-Sm&r*Ha(V#R`[rhXHL0&c1K8bLX'El[I# +[L+a9RJYj9@5YpUI,[c+be[JZrV1e('(Hm+B,QGKKcI&liGmb@@[p5IGc3+bl24F +b&m5DfqZLk%B[r-X(Dk[R3PjG@&Xm&r)1beV[pm,2lE&+24FbamF55HFH&a1ZZC! +!U93@A3Pb,Q4+P8A[@+mA)kP9&ZfCR!ZC4f840qG#jP0C%hYG809e)Dr(,,V0j9c +)Dc+VcR-KVmZXS1G#jN"Cdc`A-KI+QYlVJZj@2@qG@dN&eP1H#jQ5B$hTZC!!14a +@THr#6jDck(ii2"GqXT*eMqG#*LeCmc`A-RR*`[r,i-f&RdaRd4XTjd,Q19RhHLj +N*ScPr+F"FN(A8YSkBqNKeMV2KFbDXZlcA-MX+HYqciA-SV)#rh-K@rV!VENBbkU +b([6R`XqZXKkk0HPM@9E@`hi[r'`VDi%rAAibNEA5Rbir-FYDk-q&Rk"P2H,2KCq +SCBRrr6(D#cpKbeVXZr!6Yk`PRJZC`'8Y*4GfSS5b#r3'(%[@XDSm&c*TakVfA-M +N(D[QPSZa2"MV'Fq&c'ba-!eediA-9E(%IaMUQI6V,Q6UM"AfHL%6Ekc09"LrG[a +ZT'02T[mP'Y,5lMFr`HR!M9ef-4T1QchB3R&9+Sc'e1BV9rJMI+dA,K,IL%[%r`% +!N!-0$4&(8j!$B@e`E'8ZF("M,R"bDJBk!*!$J!#3"!362R4VU`#3%$8Q!*!)rj! +%68e38N0A588"!+a9%Fq[Y-Yp!!![,`!!2`J!!![*!!!2YIY6AGS!N!ENFJh!V5H +6di&XE5+l++HFFX1cP"[YV*AC+'mPY-e@GQ[AC,19hFTZVHJ46[J4TRPbHKjEmcH +qBr[BGC6XBrR&EK[E,,U2m#-mbGE1cD+EF$GKea(+4rRH2RV**I[@IDaB!m)ffkH +j6iYX,lE*`MlhHARZNfaAi+X'YGEAXF[VD(*k2-,2falCja%H@6MjI@56cI"Ni`0 +BJ3-DC"F!!i!KQ3$&H'V&GGF0Z,[h$#N8G$S#NMM-@$)$VlGrfC2YGVZM2Z#9M)' +!daL3!$dDd)$9DTYYUCaDcT)e!2NA(HMdVCq6r4M!q&5!S812A%i"Z1'kGIIIH*Q +qAB0K051-`ih$DdChB28#Z'60ZUeA40+XYNV4ALGj[D2(I"VaKKZ((HDP!FLpIGe +$1lkA1FRYFhK&fe4,4G!BP"ai0add62N)+4d%rMq'LbbKN!#Ej*d["l3)T%92(F4 +Va"[[iAGq'Q54VJ,!)[C0)d9k1BcqqD'h8-cd4iMqLIkI`aTCQZEU*)i1fG5#Q3e +P9EaZ`2Sm@+aj5+1&0Uch!bLi"[qA3!U$5#3''iR%AGF[iCLEEmEZ%+%I[d*+TD9 +Br6k(dpqTU!"&N!$1fM5,i[m2IF6'F$RdbV)kR$2YSXeQ%DHlII-Nq3L6(S6m#6E +Ep$-@V-Cc3L$J93IJBE91RpL0SjrZVK'ReJImFSLN2BTKY8fIT",!Sp*5TJkJkfc +ll'-%2q4489j9S6A@e$RTJZB2DlR0Ir5E+MbcX#6$Z6XIe8edH,eq[dqF)RN$"20 +L*),hcD"IZ%YB,K)0cN0Mj#a1I$TVT@JCDLNZ2Z%1KBGJG"BAU`,`d"UG*`AjJ!I +*VJkJDk#6b2XmT!8R"IRVTrLelMpqT3DKm1K5ScIbX$N`Xf+k2#kXSQ[!%93,i1( +X9,CE9`T)a#1&H,c9L8lcd"L2j+6NTjdYAI@HAi-Rqh3+bM!K@-rl0)IjFjqZXXc +Xb6&C"$+T+mQir-ljrfe"2(r)3ENV0*cL%DcceR6Mk'hPEkZ+2%,c93*iF(mDd5A +reY9'AP350ie[9%X50dTl&11Ma(f#KfT!iTijFCVBS`I0fpl@3qdMZ4pApD2NhXA +MrH6H`q08FZr4p94blqDK[T!!h)rTmFrNIN,B$j0l0ip6bIdBMBq6HaF2pB$N,Z" +![AE'eNA!RYS-ZVR9GC&Ac)cUIF-LC'cj1V5a`XB&@jXKE3@+m`,2+hLrfEbXqMk +Q'cb5kZSILIZim6p+h'pf@0@!a&hTpSdB,LiB-rU0a*hqMm5%4%jfKY1*UB[(qdQ +R4ip65DHEaqP1ISc(ajfmLiI@f0Ae8T%('VmRQTrT-!NHARGRfcXifAM6DF6$Aq2 +Tj$'caY20)mekI*dMEJkVCBSUJ1M[cKT583hZk,GjB+IbGQE1E1,KG35$SX9I(h" +l$kXEk`cSD1P+93"Gch5'4#E[b[DRHA4hi'kI*6TRU00QTlk-NEJpCXG0V96@M%Y +J*VV$Y%q["2eA'Q$R$kRf!02Z8++(I[(Pb[dG&-JBT'lLNcI%D!6pYFh4fJk1Trm +L*ZKRq*e%di[K2pfU5,e*,-4@LAKC-I`22Z6IZM1+Eb0mj2Amhr(2[rDEjP@rY8& +Z#@lEN5kiFF@d*T0*VKNPMKJkE1c3XCHBm'L'r2S(SHm)S2Q!%,kP&I,YB6M(YN+ +ikF)(&5jIf#D%ej3*0pDAB$8RbR##%&ke"r(f6`&"L'cl1@fZTH%G2KH-E,Yq"C5 +1$m`U'e&'GF,(qhaT,4,q[lK-L'H'f[)pN!#lB6HajIAmbJ,)I5Q9e3NlX&l0kmU +H'XH(l'*d8l'b$4GH&B$m+r#F'e$d@lAKYU@)PI0%k@e,KBC0M8*$1pIGj)(Hk!& +6[6YdFG$[R'FU6)fdIHP6NECP$ALZ34LYm-b&@9JVL,4pp68mRq5DYBQ'50X6b#@ +q,UG`fRbJ@GMmkkT)ff-"BH8I@i8Re`6S$Q+YK*4R5q"R`9CKmh0ijlR9N!!jBi( +#j5GBhfZ,d#iHV0B"V+PqM6bUkCH&1,XdYANAS(p4+YU6(1J69[k!cdbT1b,ZGM$ +hhUUpCmR,R2r+F"(G&kl[aEN*erAI5Bi90MpIK9L2!q5C%5-26a&2!ji&V!9BRk3 +(h$kRGlj,-KfZchGlA@*)PL56G@U&#E2Mkj!!,Gm1#5[Ub)Z*[Y$bV3+KTDNNf4G +DQXb*[R"eDl`[)2l4[Y$5Y!JqXf8Mj$kbI-NBAQq%r0TE)2I9YGJA@K$Lbj!![I6 +a*KNSrJKiIhANaqY`[cAD&eUDpS2MPEk3!1rIcrY#5e1F(1U6KqE5$$-TD`lfq3& ++ULDErh15E2-kI&LbL6CCFLS4cS@$E)G,NS18(c6-G@F*'1EX`R-ERkLjlKa%iS' +Kca#X(F!c#h+ZUB$XTYC#&!EV)V!K[iShCYHG0U8q*-5+Yk`11Q8hR)h0%I(j$UE +V,Ja"U!r(6dAmpBq$)5qa2eRiYA[-0pa(VZ%j!r(Z!X2jkpQiRcCLE6[bDq6p2lZ +T3F&(23MId$mfBXQ$rR`VGLGSmYrd32'@*PDkF$F"QTGYH)e1K@0c#-mL0Zi"[*Q +l2DET4%M9J@k!)Dk6B3*eSUk3!",P"kiS$kTMcb-qE0aMlfbB2!p"1!"K0ZkU91S +KU2pbdJ6aPEbPZf!jC0qdPRc!pEL9QINCp`&jB0!K$m6F2XIRrLcqar&al!Eh3'P +C&R1H-j)jmhDcdRlBB3em8XUFIE2qh`1QAbSTbaRP3AAb!2*KT92LkDA(!k969R- +21-r'UBN"pHQVq2f`"ajNIILCp-$&EhM![M!BNZV&mJ8Kf4'-qi#9hG[)22Y$H"B +abmXBrR-fFZdmHcrT!a-I1X!,RLJ2UT-(N!!2+eYrbpmm8(Eh8Zi"cclX!cNE%Ip +B(hLBCI-ci3'H"iTXXYmM181L2H3)ZIdq59iib26kREK,e#(b!"Xhkb8eJ6a`cU% +qJ!0"f5'l*I3mjB'S6q0j3&fK$j3[crZJ$e5rf`HqcmE`-pN(-JpjJ#B2CZ5b"hf +R$k12LK+#aAfX3BiGIF#c0p%(2(X2i0R4"cal1rS!DRbb$hMfGI3"VNGl,Kc`ZmA +*2Z$CTr3"lY&pfj&I4amJ2Blf!446KbmrC0MGp+k%1&'5cQ`2UACm0)2*8'Z4rU! +*m$-NAZ&)2Tf4cTr@`*2IdX0C@1&(&'Fc[5##'m,P,RIR`aCGhhMmP(e6YUKUPaU +!SX3RAV`83Q`HDq9UBG+iBbVAq2"V&50aJU`)Rp2qi)SXAHPHm2VJ2+iqImZNrGj +fTEXHFCIUccGhEM$NN!$re9p8!Ej4N!$fLD(TUCD$R`'dQQJr6Ej5Sc4DZN&rXDh +bfE(UKffBJ6rRSdEc28c$Lpl*TjdXa[X2J8`1"Zfa@"50,$MBV&+@6e31E0XHS2l +br*!!NBFHHSIU0#&"05B(+Bj*2RR9m4bB-&BS2ImP[&,!(J!0"9!i$r)$Pp+D'9Y +XVjJp!2q[e,k3!+!N0'-XTfL1ApPhJ2DZ,U"DG3(3q()De6lI!26S!9mb'@q"@IL +A1)+K(Uj!2[aKKH(2JS5ef95EZaB`0M#q!6Mi+8$hXeZTeQmQl@qa293Ee3H@!I6 +P)rbD*A!$32qP9$2eJ@rJV!VVb1qlF!I@eP1YI$$J'(c!`aa[,Mb#Y8HT&PS'q$a +C)FI,(!kii&()leff(ICLE3I9VVUIp"Ti(p9XYf-hJB&i&d!-Bm+!JArL'[qHi6V +A4AcXR9I+m%@bLp!V!!dL+m8DA`kTU')iEa[%3hV'H3cA`!CYSPVG[3ap-1K&EUJ +`M31,B`BpPla)"HeqZMIi9DVe9RC$+afbcqfVeF8'b&Chd*NC+k*PJcK0e[2ecrL +bB!BY!&[m,QQbj%Y2,!2cDe(NXbb1N!$$kkr9ajJSXrN8'V(iC@'5haG+UA$)Y9* +)0m(TP(!6dHB)eH&p$T0"EhT%#@C4VF`Ga'e&UEi'fDFR([cJ1&''HNA1Q%E4FP6 +GB)TPNKA"-U1EpM'8@$d'Nd(2Gm@)8be*22'feeP8`X9VMKF93+Fm-B0#qL5[$VI +Iibcr"`h!q0KDjl561mV0cQiIkq`pQfcfHIYmHMR)IMefkkB[Qh5qH1T*ApDDaYF +cGQ[PPY$)INBff50''1&Z,pDRa@iIfC*0CEDCl50XRld5hT2E4jjhZSeY9RVjqpL +@X'+rYI,**SYN(q(!MGKYHMD8RE@'hfa,Z*Z-'0P2EL@862D466B``5XHUfBZAIF +#J),IX3"h2ilIJqKci0H+[ld'U6!G,$!fVF$[phTFUZ(4I@qL+DkIhjkrSq5K9lJ +KMjV&JMb!bDQ&HPfGkR0VJH#MEr155c69#!@di-`CMiTrZdc`NKbU6`[kM0aClr! +b5MaH,IH@h()MS+PeehMT*0jDE[%'c@F%raDr**XRD*!!H-aq*aj$bN0q[ai`FZH +m`dYa'Kk[ar"S`HXmQkFUS!EHjK'laKZ5@`V+M,--"bq3!%Ga#"qEXAB-!L8IUi9 +PIkUY`%8U4*l,hbdL%RlTV2*84I(+#Z)"#kAZ'@Uckfl0@q3*D#j$$l6$)mfh[-Q +Tk)&"M*V&U-ZUeL1e8h#NHGCcJMVV1E#fD(8%G,m@-1SlY)CI6K%4HMN&NN4FR6k +hVR@%4P*rjKA8RhPK-0-kc%Q,#+XKpTTf1LUF+lA1K5'-1YaC($B#UXXS#HKe"F9 +&@Y$9!ND@,UNk*&2Ual*XP`Td9cD%MreD8)rp'P)B0F-Qbh4hD#0lrlL,8p%$UC5 +k-FZf)+#VETFD0,UjNI!V)iA@9dC#'U1QfdL*e(ba,%,@Xj,k,+3cDUE0S38mZKX +MkqhL4KSr0j46d3-CP,SqdeDN'LUVpGh8m)NG3ZZ*(C!!bDLTYLY%5Ue2DZC8p%! +@THj)TR'0-C'kbIY96N82C$0U0U8Z`J45ZdSH8Rdl"G@h%iC5kXa8fi+3!'(deGI +QD3G&cCYf%)BaDTUY82AhPH9)q"I2L'cia613!#1TZXm)k0eT4kK2leR&UHL"QaJ +e`eEN8Eekc3)ph&04`UIA#+fRem"`35efHi`5MqCepe#r&&Bi&6d`JP'6ED3*l-Z +mVjamL&24!b-C041ch0dAfXMH(EQLjZh)K9&#kh+2YV&2k`(A"Nj&$i`@qEV#Jih +$C@kNHHBqNDmcpm%B3P9qRfjE'0!hVYCMXBf%ca`41A6Q#0c-U-NfZqB,p8AS#E@ +'8p%$BaNeM9)AU,(@*[*%j9&"V6`+lf,8('H*9mG@`eH$lFRpKZk2dL20NhD,Z%l +D$H-)&@CNBAP&j$V5bJBlp6DQ[XMV+r(!H+Vef3aRN9B9UUP"FQp&qGAc)KYqp6c +N-QUfXbLJEN4QZD%DRAN8HG)hQP24!a1Le0i34F*Rj`LYCqI!4%E0FKEl0RJ#ZUm +1'lhZIZMX5NPG#Hm@F5d1Zl3VG6QbqDHLXd%2[)G4-je,Y(UFC@$Md*9#41[ATGD +[`b5KeDl9kB(kcLD884Z1,1&8p-!Y)Ui1c&H5j6hF52MFRi6@Fhq#@d@%bM69jkR +Vk@Z3!1UFrN&143p-&K%UdfU`)m)C4'q@RemRY*jI"lF*VH@ZJ+Ej($K*kFQ'mk) +1S3GZ&p3+,@a8"&52dCY$jbp)kJ@iJe(6R+b@Gb0Tc8X+LCUA&))TSRmY-!c99DY +@HEZVHF5CpjM)KVc(B'SVYEHJB)51[b%LG2`0b+28F6N14bkYP39HR'd%m`,"J+Z +P[Rlek$,PUE,bXN,LJ@P-Dik0$LL+2%'rDVKUfp[cb&HqB4GGe$IX-*e5pfFl+iT +*&XAQ2C'YpMXi&6d`3p4AR,kS11NK,@*hI6eh@&D8`c#6aA8%aTAT*1-l,%I4d$E +HpcTQ!idVHQ!@ke&S0apV'SM@,`lDU1bL@Y%$la9G,qR,BpdVLG![RCb+(TJYU!k +2Li`[Bp5YPXfFLKkB`kKC0SGAG@QPZVGRrS)+cdZYjf%ZSkEED&A@3ldcKdMieH' +#qZT`Z&03X9,UAL`-[G6QqAQFLKkB*kJNadP[IPRVLe,VLc#IeeH(3kmUp+V"S0C +6ArG89A!UHZ"p3QZ*lJS&,kFHcJXL3Z[T#,bI8YGRfdTaI1A9BT1E52MN*N%pZ3R +ZBV8KdeDQZMdkYYQKYYD98epE,DL[VBDl49pHS9CGCP,UB8Np$2H`Z!kM-p%0@Lc +r)She+cJ92C!!Rjq-SrI[T5rbBBYAMH8""l1G@KZAI5&If48d3PA%!`@-QXfQSAb +fh%&Z$0je#+QehLVLJ3@%DRNKdlkLX#b%M9kGPYHP0Y,ml9H9AAD(VB4iS*!!6E" +5E!@"J0Sa3CA8!kA2m,LL"iSBG5LMAKjm46ieSi&6d32&M*T*jT4qY3G*-qrBTdA +Q(IXdP1$'!ScGNVk`[,aFVF-4E%q3!*VfeH3`+[(!3NE0[%M&,1V)KUCplZmSZdJ +$3Ma3fNjYDlXBe4MPiP6d`+,m34MA)F-FMR@dBb[99,)UiA!84R1SHLIXXYX,5kP +R-G1DGP&VE9IQ0@hjq'pjA0%$5d3hhp*lYC1ailS!2)I3Bf29#r1eYAT&Z6Ja(#k +Sk,%6+Zc1+5Kfk"Ze!2Bh2Ua'(Tc!Y(!M'B21F5Va,-e2!KJm,VfJQ!m"kVX$fcL +Ki4#M8Xmb2Y&R-h)q0-IkB,4&k1@[L3LKam'd@U[p2FNMU(ZIRXHTa2-"4NdVdi* +k+1$#[UBE(Se3QHJ1DG0!1TYZ+RChGiS)SDGF8"HjG"qGF-DS)b4e"&5)15Af+,( +#3+LE0T9b+[%iaIb9p(PmYYb*MRaUrRK1*ClPE*kAf6,2km!fVYQ@bE1"H&D`kT9 +4L1@VEbcDY+rfQ+M+YFGJ*DrPPkKGX@hD8Ki80Dmm#+XBGGLP@Kl3UMeY#GKN61& +p!r(!DPD9KdDVFR[0fr14$r&X)*jlQGDNQQ"[9H"De5-RZ9Ed`(hj+3!T8j1afT% +KaH9m[@I[llK@iPR$U%2U0kMG+5FlYTmXiP6L@BXE1P!D6-(*jY3ke4AM0P@Z1X' +Se,11D4dFmVAR6@Z%QViP)S5H5KkKS)%0GPq%@Z1UFQUebfGiVe+E[LQeIK1UH)5 +#111p'U%[RhbB8iR(aDQdhldDejB)ZAQqBMCJD2[bY58E0"lA8&aXP&V0U#NKh#K +6Vh#Me"UZe@A8qpr5Z[Fh-UkrJ9T5'aD2bFEUTISpkfV)JSkRSd3dMIrZ+9kpd!- +H4NeQe-YLQj`rrL5[+-5cAYBmYpG6pIHDGcqGE@c2,&KD[LLh-!plj*iTaB'ECr) +T"AV!5kQlKpK9SlCRK-*kP"pY&4-4p%!GS9TqN!#&R9G3akk"$&K`KY91RIhl$*B +0a!-qRUq#HL9Ire+pG&U9(dM&9##Y3e[[Ic'(RVHaZ")2q-PHjUMm(2Z+[$U2-6@ +SZqkR+B%U@Q[jDTa58#Tki!&+AC!!+T%p)BTXqI`%(L(L#G!Xrf'bAA99&$UZj'[ +$SGXiPAL#6'Zfd$U9e+11CL@5kHIG)I8BBR1,,'THhG`k+DCPk)%3SbC6DYrZ5rM +%IN%pX4mfX)iYLr5846Kdl"fcBrrC,$[4CYM)U*NYe)kF30Bb59d'B4UKM`fc)E* +[43rRq20%K)l2JhUaReH1cD&A3hE[9X6a*bAe5GM%U1P%DbbSK0Via!j143mm5+R +M4T,Y!Fl0lG`J`*d"9@RJf`-U`-3'F#VCq1-BZMe-c8)pjYa0@JPrep"14!'9eN8 +&2,4E8-"'CdS+"'KG85")+i8#$p$UT-"UfRmVX)K1aa5SS[fG!T@dEe$J2[jfmEH +EpNN+V10[MEqVqAXYlAX9@%1lCJ8fdJa@B#@G+5K`,qhF&DLP2C!!!S[TI%f"9A4 +kS#L$&H`HB(4E2TKe4YU'rR`Bb)2erc8K(hJH3$9fP3"*EAPJ6RkNVH$[YVJ+hCI +bEG!Cp%GeQK0FD3[j'q-YmXfkIAX$rqZ3!(AlcKGSrDNQlN#pYHUjkGB(ce6H$i" +ele5$YHT3!eL1Zm(blB0JH4dR9DrRJf9h0PJqR`b@Sp[`qcMkTS$PjcH"jE1I32q +(`I)8lY2rp[YJHI`8XJK[,'V!piNpB2Q$(rp(jKmH"X[6q0r4-,k2JqAr[FK!AE[ +a[pfld)GD,k#qPaci08LqpHG"pdaD@QPR(PJ,+Q8H*-h0jRR3VG2Fcj%f8pCpS4L +XMqbTK1AFZ4BUVCZrda$6DHih5F[VeEQf9@HXITLGN!#d"dAHA2b&eLPHRkbIqIi +Tkb1,ml&HN!#qB*reS@PBpD`26rlG)I,#1Y-!Iak+[+a"fp&r#,m(m2X'8d+Z*Z$ +GJ@eiJB&%+"Rr,-8[AQJJr68DcK`B+*E@5bFJ@%'QJ9mrIV%URpk-ljAiG31qERh +8qXM5kE*Hmq9qfEIdlj4,)p(YUYG,k#E"aEi!mij',kV6h%+A*L,HTV0IRpPl5`X +Rp*RpYV40#AhQ&%"DrA9p109Tk42kY`fP6Ifh[YJ1T,3T#AhQ23*TU3PpjSDNY'N +*IHCP"'PT!rNA[k%J,Ifk2YCr5(hQ93*T3a2kc2X&dSEeka0p6P5IZD%Rl4lq&R1 +TImEaVBX+dR)5H@,HAT!!GY1![[L9"QR$%rV-$9"TlaZS)r(GAQR[6HJcle&)'c% +3[rL@XE6C#AhQ2V+d132j(GpFPMCh30pI+cLc1a2kc-XKdNB1a#qqE5eYhN"pLYm +`N6BUSFqmGL*Yp(9pZ(2C'VriPSFdFTIUArV-h40TBX2dKMjc9ehDq`IL&lpk*#d +MSFqmMb3YmlUq`Dhkc$YJdX4m,+E2KeY5Z+lETXqm'#C0c%rXG$YCJD9dQrGD[pm +6cmZhaU5*1RT$RhPI6*VJQR14U$lc%TQd)IbpM'jBAmX6`H-kc8X#dX5#h!epjXd +"D88*IHCe!QR&#AhQK6&T@3PpjLdbD@6EkfepBKrJBPrleYd-DAFRp*RA2+6GGEd +14[@CPf5NcH*["ldCF+d1YZZ-Adq8*[C9rT'(mEYLdXBNp*NAb+6GR0"RhLU6KTG +-%hNH[r)S6I6&EISq`2[%rMLDep1N[5Z4*qCY*QRN8ZK9I9[KSrKhLYbl%I@frlk +2Y2Rm,HEPCI5qK3,Pp'+&!Z`'K3*1HPAL5Vd8q4U0JhP26YUihMJ[ThFT1[)TUY1 +m3#GYr29mMHScEp9*brf22M04*L6dQII[T%e-k$-[j8PlGd+IH902fRX'iKHr[LG +Yd[@qT6frieI9T-hSe4IEdf[2mrJp3'Qh$14Kr(+JY&X(mM"qBe$Dj)(iaDm45VY +Y3&rmEU'dfa2kc!Z(dZlSeiGlYh5[9ZcELIP$rddcDIRmhD[$[()QV5#Z`lal*Qe +"[ilqbb65F"(iUJlcTSFdNCfp1Xb,)Y*drKCp495(H39&QVLRlZ2h#Ql8"I0'Lc4 +bUCkEGCje'r,aJX6Srh18H)2m(cF1Ih#lCf+$`aDmG!I-3LDl&NHj9[2Qa@eTR"* +C*T0rb$cYI`!!'IB!!!: diff --git a/src/mac/gss/GSSSample.cp b/src/mac/gss/GSSSample.cp new file mode 100644 index 000000000..0ffcc111f --- /dev/null +++ b/src/mac/gss/GSSSample.cp @@ -0,0 +1,222 @@ +// =========================================================================== +// GSSSample.cp +// ©1997 Massachusetts Institute of Technology, All Rights Reserved +// Based on .cp by Metrowerks Inc. +// Modification by meeroh@mit.edu +// Started 2/28/97 +// =========================================================================== +// +// This file contains the code for the GSS Sample application + +#include "gss.h" +#include "GSSSample.h" + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern "C" { +#include +} + +// for mit-sock +OSErr MacOSErr; + +#include "CGSSWindow.h" + +// put declarations for resource ids (ResIDTs) here + +// AppleEvent reference number +const long ae_Query = 4001; + +// =========================================================================== +// € Main Program +// =========================================================================== + +void main(void) +{ + // Set Debugging options + SetDebugThrow_(debugAction_Alert); + SetDebugSignal_(debugAction_Alert); + + InitializeHeap(3); // Initialize Memory Manager + // Parameter is number of Master Pointer + // blocks to allocate + + // Initialize standard Toolbox managers + UQDGlobals::InitializeToolbox(&qd); + + new LGrowZone(20000); // Install a GrowZone function to catch + // low memory situations. + + CGSSSample theApp; + theApp.Run(); +} + + +// --------------------------------------------------------------------------- +// € CGSSSample +// --------------------------------------------------------------------------- +// Constructor + +CGSSSample::CGSSSample(): + mGSSDocument (nil) +{ + // Register functions to create core PowerPlant classes + + URegistrar::RegisterClass(LButton::class_ID, (ClassCreatorFunc) LButton::CreateButtonStream); + URegistrar::RegisterClass(LCaption::class_ID, (ClassCreatorFunc) LCaption::CreateCaptionStream); + URegistrar::RegisterClass(LDialogBox::class_ID, (ClassCreatorFunc) LDialogBox::CreateDialogBoxStream); + URegistrar::RegisterClass(LEditField::class_ID, (ClassCreatorFunc) LEditField::CreateEditFieldStream); + URegistrar::RegisterClass(LPane::class_ID, (ClassCreatorFunc) LPane::CreatePaneStream); + URegistrar::RegisterClass(LScroller::class_ID, (ClassCreatorFunc) LScroller::CreateScrollerStream); + URegistrar::RegisterClass(LStdControl::class_ID, (ClassCreatorFunc) LStdControl::CreateStdControlStream); + URegistrar::RegisterClass(LStdButton::class_ID, (ClassCreatorFunc) LStdButton::CreateStdButtonStream); + URegistrar::RegisterClass(LTextEdit::class_ID, (ClassCreatorFunc) LTextEdit::CreateTextEditStream); + URegistrar::RegisterClass(LView::class_ID, (ClassCreatorFunc) LView::CreateViewStream); + URegistrar::RegisterClass(LWindow::class_ID, (ClassCreatorFunc) LWindow::CreateWindowStream); + + URegistrar::RegisterClass(LActiveScroller::class_ID, (ClassCreatorFunc) LActiveScroller::CreateActiveScrollerStream); + URegistrar::RegisterClass(CGSSWindow::class_ID, (ClassCreatorFunc) CGSSWindow::CreateGSSWindowStream); + + // Init sokets library + init_network (nil, true); +} + + +// --------------------------------------------------------------------------- +// € ~CGSSSample +// --------------------------------------------------------------------------- +// Destructor +// + +CGSSSample::~CGSSSample() +{ +} + +void +CGSSSample::StartUp () +{ + MakeNewDocument (); +} + +// --------------------------------------------------------------------------- +// € ObeyCommand +// --------------------------------------------------------------------------- +// Respond to commands + +Boolean +CGSSSample::ObeyCommand( + CommandT inCommand, + void *ioParam) +{ + Boolean cmdHandled = true; + + switch (inCommand) { + + // Deal with command messages + // Any that you don't handle will be passed to LApplication + + case cmd_Close: + // Quit when the window is closed + inCommand = cmd_Quit; + + default: + cmdHandled = LDocApplication::ObeyCommand (inCommand, ioParam); + break; + } + + return cmdHandled; +} + +// --------------------------------------------------------------------------- +// € FindCommandStatus +// --------------------------------------------------------------------------- +// This function enables menu commands as needed +// + +void +CGSSSample::FindCommandStatus( + CommandT inCommand, + Boolean &outEnabled, + Boolean &outUsesMark, + Char16 &outMark, + Str255 outName) +{ + + switch (inCommand) { + + // Return menu item status according to command messages. + // Any that you don't handle will be passed to LApplication + + case cmd_Close: + // Always enabled + outEnabled = true; + break; + + default: + LDocApplication::FindCommandStatus(inCommand, outEnabled, + outUsesMark, outMark, outName); + break; + } +} + +// =========================================================================== +// € Apple Event Handlers Apple Event Handlers € +// =========================================================================== + +void +CGSSSample::HandleAppleEvent ( + const AppleEvent& inAppleEvent, + AppleEvent& outAEReply, + AEDesc& outResult, + long inAENumber) +{ + switch (inAENumber) { + + case ae_Query: + // Dispatch query to the document + mGSSDocument -> HandleAppleEvent (inAppleEvent, outAEReply, outResult, inAENumber); + break; + + default: + LDocApplication::HandleAppleEvent (inAppleEvent, outAEReply, outResult, inAENumber); + break; + } +} + +LModelObject* +CGSSSample::MakeNewDocument () +{ + // There should be only one document! + SignalIf_ (mGSSDocument != nil); + + return (mGSSDocument = new CGSSDocument ()); +} + +void +CGSSSample::GetSubModelByPosition ( + DescType inModelID, + Int32 inPosition, + AEDesc &outToken) const +{ + switch (inModelID) { + + case cDocument: + // Assume there is only one document and always return it + PutInToken (mGSSDocument, outToken); + break; + + default: + LDocApplication::GetSubModelByPosition(inModelID, inPosition, + outToken); + break; + } +} \ No newline at end of file diff --git a/src/mac/gss/GSSSample.h b/src/mac/gss/GSSSample.h new file mode 100644 index 000000000..d191ab4dd --- /dev/null +++ b/src/mac/gss/GSSSample.h @@ -0,0 +1,52 @@ +// =========================================================================== +// GSSSample.h +// =========================================================================== + +#pragma once + +#include +#include "gss.h" + +#include "CGSSDocument.h" + +class CGSSSample: + public LDocApplication +{ +public: + CGSSSample(); // constructor registers all PPobs + virtual ~CGSSSample(); // stub destructor + + // this overriding function performs application functions + + virtual Boolean ObeyCommand(CommandT inCommand, void* ioParam); + + // this overriding function returns the status of menu items + + virtual void FindCommandStatus(CommandT inCommand, + Boolean &outEnabled, Boolean &outUsesMark, + Char16 &outMark, Str255 outName); + void ListenToMessage ( + MessageT inMessage, + void* ioParam); +// void ShowGSSWindow (); +// void HideGSSWindow (); + LModelObject* MakeNewDocument (); + void HandleAppleEvent ( + const AppleEvent& inAppleEvent, + AppleEvent& outAEReply, + AEDesc& outResult, + long inAENumber); + void StartUp (); + void GetSubModelByPosition ( + DescType inModelID, + Int32 inPosition, + AEDesc &outToken) const; + + +protected: + +// virtual void Initialize(); // overriding startup functions + + private: + CGSSDocument* mGSSDocument; +}; \ No newline at end of file diff --git a/src/mac/gss/GSSSample.prefix.h b/src/mac/gss/GSSSample.prefix.h new file mode 100644 index 000000000..84a0c9615 --- /dev/null +++ b/src/mac/gss/GSSSample.prefix.h @@ -0,0 +1,6 @@ +#define GSSAPI_V2 +#define _MACINTOSH + + +//#include +#include diff --git a/src/mac/gss/GSSSample.rsrc.hqx b/src/mac/gss/GSSSample.rsrc.hqx new file mode 100644 index 000000000..386f0e237 --- /dev/null +++ b/src/mac/gss/GSSSample.rsrc.hqx @@ -0,0 +1,66 @@ +(This file must be converted with BinHex 4.0) +:#d&bBfKTGQ8ZFfPd!&0*9%46593K!*!%$%3!N!6Yj&0*9#%!!J!!$%4b6'&e!J# +3""B!!!d!$NG6N!0KEA"XC5j`F'pL&!!h"MS!N!1!!*!%""-qG2Sc!*!8![-!N!6 +rN!4bFh*M69G$-J%!Vcc-4kq`C--!!!6a!*!'!Qd!N!4Hk`#3#0lA)d31)LVk&*% +6PI'MEcl&Rj@91$0LZT`a@@fR&1[8C&eL$El&mA%V)j')P-iSh*I*D,hF#I9U3ip +eVJ[-Fe!ZG`a&h2fqXqc*P6E#rqdSLrq@&B6pp8*Phj`3d1*mRD6VXUDcpQ!,Dr3 +YJZ2(TELH#DaVEaNHd9-L2GIMaK00K0Fpbd4e-4fDcUHQ)K#Ad2R!`NBP-%&QBP9 +cVjBe'C)Al1KPHVDP*bZpk@U*bfC4)'[5HJ5DTQ@'+%"8(*B-Np0D)'N+Ph5KaX` +9R6E#&4ic@E1L8(-q4MS&@(X$)e5"kSfU4cANV4T4-Bcj!l)DYhbN!Cd-X()!bN` +G2@lTp%@HcKcj9PRKVM1cXNPR(M'VKH4#FQUp'i8CNc!'!m"@[Q4EmAUSp%$"8K& +2'RNGLi6e!'1fh1'Lmah@!jBrDPc"X"4NqeME(iB*PGXjjXPXmN&6F-J[D01)*lX +(d40N3I)"L`rbJmSd@'#*'LqiQF3aMH"Q'6e)%`YQD%*BUCXKFc1DEV,'qBhc&l& +i62'PCG2(iePQ@'1HFS3b5aDLki[blP)b[CKc8R3K,42ZL1hZp52ZB*+qq%lXLM1 +cA"mU*!8eUM#(i!6'QX`Q&lf1-08Mm6VA6VLBeICecEhKA(#UQ$J6[8DPIiUpLh- +dcYrF,GE6Z*E3'R,5fCfaG"cpiN!ih![HKR"B%rffGHfK)2UGhA+m!rhZmk`&EYq +6JYM,cTf*LiGJUH"L1QaK5mQ$,M'[JIb9HBd!G1rR0IUJ@jhA#%IhD"iELJ5j2$B ++LGk9amB#SkY,dCa"l1,L`YhUaP@GA-hf5[VB!U6MmJIS+J!!$3!14e13!f&YF'a +P,R*cFQ-8!$F'1J#3!i!!N!3%%cjdZHm!N"%@!*!)rj!%FR0bBe*6483"!+mmeAq +[G"KM!!!4KJ#3"JMK!*!%TmB!N!M(hJc!q+l2bm[NjZ9YYZNq"X!lMqcchC5`I5a +br'+%NFeZjI6k*0b"D4%@Z@eN%i$9!1MTC[JdK[I@hMMjcED4fi5666Ej65DE6$D +jEC*0*TYXXSm-pS"XQl!p)2[B2X)fqIfk"cBJ[mQ@l,FMNddf'91J$[ppZGPQC(Z +4hj,I"!fE)'1[i3A+bim5"85dmb@L5Ab$c`'Ff9%2XbMekN3cmMDV8)9Umr0R&Qf +hILp0RUVAklUGaQBQFePS+L"NB+&qBLkJMBdYP2(E[bmF[IR"(,RV)rfT0r0MCYp +&&bA,UTC#Al'%9'GH[60PRGjRe[XeMihYTfY-'1`4(CmLfLh`)hqJi$Kp0Rcj'Rr +[D1IIh9q8PHIBPr!iT-f+YcT0LDTr&UaT3f#[-*EQf&mBZp+*2,#rJ[16SFe-'0Z +%D0Y2#X`"qkPJL6I!ILCBCQ*J,c,@0,%&GP-`DpD!rCba+lEa!@#rB'cCq#D`A`U +(LpD"r8VQ[)Q![F4Bfkk`[PmcjV4J[a%XjriYpR0$pYMJIBerY4fjX''@`6rq!Q1 +K6E[![LCBfQN!qlTJ(Dq!IB1aTRABqrJh'62)!@$I%LaT-RD0XDLpR!(lYQ#Z!bq +-IiHapNS%,iarPl&81qEl(Q1mGD+*!i+YC$chIFEJkcD`(c$@5CKMr$TM,JkCiiI +Bjb3GT[I6(i1[d0@jZ82ECD*&cp#2Jcr4M@,LA1(VM`@Mp&c`f&$Pr"1#6p$MG$# +BHRCQhUkDE$l@#D*Y66*-c@Gf1G2Y(A@2Q$'C*%m8DKqaXfQY8(3U826Hi+QHSZh +d""d*RRVfdPPi-HZUb#RieR0d,AALH%E0adBlScaQ[98kMXe+T$d'@NDPQ@h%TUd +DAF@K`D61YSe#d(6D*[&Z4Vd-M8p6"E%!2p2dDT3dXBR+Slr28iYcYFa@q0S92,9 +3Tr!,i[Skl3l+M(XA[SG,eZQ""CcZZL1UCH,BUP@EaC!!!(-lI'I!pL"9*im@lP$ +RG0ZmCdFG8D014R"0c4hC2UZ6QejG&,[5AIm+fYY$XT'p0,BjXl%aFXSNCN8$8a! +p4(m,$Z'eJ6mf@RpI3MHq[eMVm15#34`M893GU@`H@M4Cfm&IfLZcBZ!lj(RTC19 +DYK-hPHZNU8AX)((C6ld@-!Rh*dfG&9VH-Q[EEE!L$b"Tb@DUEChI&14QlB)4"D2 +$l''cFjCI5LF+AM5K,aY"JM3JZNUB8V[Cr2Ni&QA&r)DQi0F4K$KLJ2#dr$hQ8K0 +'5j&aDV9P3*XT,#'aAS8YR5aMV&KS`m$&+r"!`f"0TXb6jkJ5*A4j+BTe(,Rl@$F +`Sk)%HU+`aHUC9q)Sh`Kf00E8ALY8$R2rJ['G$!E!110-h1Kkk,C,@c[QKS)5Y(b +J4`@'[USH-BN$$JiQ9eYXQ*jNMP"X"3[04,[K3%2A3UcZ2f@mD")bYQ0["93fTJI +aflIBimKXHh1hZIUh[DEq9H&$EAhCl$U,Kp)U-D[+),'4c@@MBchhRFqeP'E0C$F +XFN!),AN'I"bLUKLmE-2BGe-cc84KV*fBkJjV4AZ+%YI#0hk)af0EK"N5VZGL6"[ +8Bji[U1(MeFLhC,ImC@I)I*4%2Y*ahd8$8VKrTl#LQk33K14*XkE(VZh$Qp`V1Zi +J"8Vf2PZj`lkH)B`QdqIab'1N-%QcF1$Eh30Pdpl-b'1jTm55,'"'S@D`1E9#NRQ +@b8N'[B-8k$Y`"QP+`fN@*Ij0mrakA6XhqdhYa`ID4F,ra%YL$A'`lT&d4E)KZF" +DK,kN&8rQU[08QKUSjPP48GR-EmQYrqBhGRS9QH&S+IBTjmXM29C'5hq@(I-e+4` +09kQ+VHfZBh1p(Gpd-TV[$fRlleBMT8B+#VHDS1)YP3QdS``i54!1p[&"R8*[6Hq +T)GN'P3hC`Y96h"#L!&-9*AJY34&&r1+1%(BSB(5%bl&G*HBBVDP,18S6)`f,8i+ +MY*%dVc3cIcp[3'BdbL'5$C9['HiSXbbA-89M8XXd'RSVM"X0Dq0ljb`mhqG3VGc +F3J4*DmH)4RcNX49+mAkG8fK83fIJ(-DN@8ZMjKShU(hLN!"1Zm&P,cGVXGNT'Pf ++,9b"KKLjTCMehA0ERc"!&!fhE92(+9l-Xr[d,4DCCCBa'$PDjbfRQ9YRTReE6,e +jCKYGYlE0)25[YjPYlaCE1Fp1B)bGX)jGJQR2(5E62$C&3faH5['+F0(Eba5j1@i +YIiUfiCB8mCl`PXecAq[V+DCP5bR+VaaZd2,GK6RF$Y(hBDIB,+%j@jXeS`4('#N +VKEIi0eU')M'`[DEQ5T`U@eYk`cqhe+1Q8AK,5JC&KIF12klc9I9#Yf(3KNSHe0i +Nc(-A,C!!cc%VXNEq"3!Y9DYGir"48h*j+8m(#IC@55`P9UQljkcF"56##i+UGTI +a8G-e2&KH"afaGdJSmTlfRZ9MASc,LV%GTmS,L$Yid4RFX2L)JP08IP$4QH&E$cU +$6VV+LJl(Pa,L+efqXC%-M*Nr[#$236q#B&k#R&!3Ze!9GiZV"CJFql@m"flfLUN +qIDjXF$6DBCY0"iP0a3HV4aG4NTH,9I82)pL@R09FHGZ4M4e8$4`jmiA5HFL3!#Y +1-1*3+N,raVSmAff0XL@q52kRrH3UZ1XA[c&Fbr1MdLiJld"e33"KE@)ZiQ'jL`A +$&cUi@8h!c5cS#S-bI3>@b,LbHHA*cL'iH-BkrSU-YE&lD*NK-Ar8rI[Z`2(DM +prIMc'*N1GY%fEA$(VG*MY6-,Lb$+jNi[RX(lSr2c&[GJHVkqZ2"@[$qrZ1BcA"4 +IZ(6kh"c`hfR$Yfek"3ESrcj%1r&k@,"RF*XRHP'`$l-9*RmNf&9k3&(`'F&Zd'& +JAmlRq)iCA-rR0MB89CLIPhF5!I`*`Di6M&+9@cpd[!reFEE3MCYfpFP#0fl495Q +-i(iDf,2&G[#Zm[med$pZKYYRq@BQd#5RB6m%afTSLPipCYGfR8(*++kmPh5@`() +64c16aKVCMD2S@)pc[0je(QIGNcEaScJMjd"qh&6[[N@kl35UCq4DrA6i2qR,!!!: diff --git a/src/mac/gss/GSSSample.script b/src/mac/gss/GSSSample.script new file mode 100644 index 000000000..b6f8a7ca1 --- /dev/null +++ b/src/mac/gss/GSSSample.script @@ -0,0 +1,9 @@ +tell application "Finder" + set outputFile to (folder of (path to application "GSSSample.ppc") as string) & "GSS Sample Output" +end tell + +tell application "GSSSample.ppc" + activate + Query "-port 13136 dcl.mit.edu sample@dcl.mit.edu hi" + save document "GSS Sample" in file outputFile +end tell \ No newline at end of file diff --git a/src/mac/gss/gss.h b/src/mac/gss/gss.h new file mode 100644 index 000000000..485cd507b --- /dev/null +++ b/src/mac/gss/gss.h @@ -0,0 +1,30 @@ +/************************************************************************** +** +** gss.h +** +***************************************************************************/ + +#define SOCKET int + +extern "C" { + +#include + +//#include "gssapi.h" +#include "gssapi_generic.h" + +typedef unsigned short u_short; + +/* +// gss-misc.c +int send_token(SOCKET s, gss_buffer_t tok); +int recv_token(SOCKET s, gss_buffer_t tok); +void display_status(char *msg, OM_uint32 maj_stat, OM_uint32 min_stat); +static void display_status_1(char *m, OM_uint32 code, int type); + +// gss-client.c +int gss (char *host, char *name, char *msg, int port); +int call_server(char *host, u_short port, int dov2, char *service_name, char *msg); +SOCKET connect_to_server(char *host, u_short port); +int client_establish_context(SOCKET s, char *service_name, gss_ctx_id_t *gss_context);*/ +} \ No newline at end of file