IPX、SPX 范例

//   Module   Name:   sockspx.c
//
//   Description:
//         This   sample   illustrates   using   IPX/SPXII   client   and  
//         servers.   The   server   is   very   simple   and   can   only   handle
//         one   client   connection   at   a   time.
//  
//   Compile:
//         cl   sockspx.c   ws2_32.lib
//
//   Command   Line   Parameters/Options:
//         sockspx.c   -s   -c   -n:IPX-Addr   -e:Socket   -l:IPX-Addr   -p:[d|s|p]
//                             -m   -b:bytes   -r:num
//         -s                       Act   as   server
//         -c                       Act   as   client
//         -n:IPX-Addr     Servers   IPX   addr   (AABBCCDD.AABBCCDDEEFF)
//         -e:Socket         Socket   enpoint   server   is   listening   on
//         -l:IPX-Addr     Local   IPX   address
//         -p:[d|s|p]       Protocol   to   use
//               d                       Datagram       (IPX)
//               s                       Stream           (SPXII)
//               p                       Seq   Packet   (SPXII)
//         -m                       Enumerate   local   IPX   addresses
//         -b:Bytes           Number   of   bytes   to   send
//         -r:Num               How   many   sends   to   perform   (client   only)
//
//         To   run   the   application   as   a   server,   the   following   command  
//         line   can   be   specified:
//        
//                 sockspx   -s   -e:8000   -p:s
//                
//         To   run   the   application   to   act   as   a   client,   the   following  
//         command   line   can   be   specified:
//                
//                 sockspx   -c   -n   AABBCCDD.AABBCCDDEEFF   -e   8000   -p   s
//        
//         To   enumerate   the   local   IPX   adapters,   the   following   command  
//         line   will   have   to   be   specified:
//                
//                 sockspx   -m
//

#include   <windows.h>
#include   <winsock.h>
#include   <stdio.h>
#include   <stdlib.h>

#include   <wsipx.h>
#include   <wsnwlink.h>  

#define   MAX_DATA_LEN   64000


//
//   Global   Variables
//

BOOL       bServer   =   TRUE,                       //   client   or   server
              bEnumerate   =   FALSE;               //   enumerate   addresses

SOCKET   sock   =   INVALID_SOCKET,
              newsock   =   INVALID_SOCKET;
char     *pszServerAddress,                   //   Server 's   IPX   address   string
            *pszLocalAddress,                     //   Local   IPX   address   string
            *pszServerEndpoint,                 //   Server 's   endpoint   (socket)   string
              chProtocol   =   's ';                   //   Protocol
DWORD     dwNumBytes=512,                       //   Number   of   bytes   to   send
              dwNumToSend=5;                         //   Number   of   times   to   send

//
//   Function:   CreateSocket
//
//   Description:
//         Create   a   socket   based   upon   the   command   line   parameters.   This  
//         creates   the   main   socket   (i.e.   the   listening   socket   for   the  
//         server   and   the   connecting   socket   for   the   client).
//         SPX   sockets   use   either   SOCK_STREAM   or   SOCK_SEQPACKET   but   must
//         be   of   the   protocol   NSPROTO_SPX   or   NSPROTO_SPXII.
//         IPX   sockets   must   use   SOCK_DGRAM   and   NSPROTO_IPX.
//
void   CreateSocket()
{
        int     proto,
                  sockettype;

        //   Find   out   the   socket   type
        //
        if   (chProtocol   ==   'd ')
                sockettype   =   SOCK_DGRAM;
        else   if   (chProtocol   ==   's ')
                sockettype   =   SOCK_STREAM;
        else
                sockettype   =   SOCK_SEQPACKET;
        //
        //   Get   the   protocol
        //
        if   (chProtocol   ==   'd ')
                proto   =   NSPROTO_IPX;
        else
                proto   =   NSPROTO_SPX;

        sock   =   socket(AF_IPX,   sockettype,   proto);
        if   (sock   ==   INVALID_SOCKET)
        {
                printf( "socket()   failed:   %d\n ",   WSAGetLastError());
                return;
        }
        return;
}

//
//   Function:   usage
//
//   Description:
//         Print   the   usae   information.
//
void   usage(char   *progname)
{
        printf( "usage:     %s   [-s|-c]   -e:Socket   -n:ServerAddr   -l:LocalAddr   -p:[d|s|p]   -m   -b:bytes\n ",   progname   );
        printf( "\t   -s                       Act   as   server   (default)\n ");
        printf( "\t   -c                       Act   as   client\n ");
        printf( "\t   -e:Socket         Server 's   socket   (port)\n "   );
        printf( "\t   -n:Addr             Server 's   IPX   Address\n "   );        
        printf( "\t   -l:Addr             Local   IPX   Address\n "   );        
        printf( "\t   -p:d|s|p           Protocol   type\n ");
        printf( "\t         d                   datagram   (IPX)\n ");
        printf( "\t         s                   stream       (SPXII)\n ");
        printf( "\t         p                   sequenced   packet   (SPXII)\n ");
        printf( "\t   -m                       Enumerate   Local   Addresses\n ");
        printf( "\t   -b:int               Number   of   bytes   to   send\n ");
        printf( "\t   -r:num               Number   of   repitions   to   send\n ");
             
        ExitProcess(-1);
}

//
//   Function:   PrintIpxAddress
//
//   Description:
//         This   function   prints   out   an   IPX   address   in   human   readable
//         form.
//  
void   PrintIpxAddress(char   *lpsNetnum,   char   *lpsNodenum)
{
        int   i;
               
        //   Print   the   network   number   first
        //
        for   (i=0;   i   <   4   ;i++)
        {
                printf( "%02X ",   (UCHAR)lpsNetnum[i]);
        }
        printf( ". ");
        //
        //   Print   the   node   number
        //  
        for   (i=0;   i   <   6   ;i++)
        {
                printf( "%02X ",   (UCHAR)   lpsNodenum[i]);
        }
        printf( "\n ");

        return;
}

//
//   Function:   BtoH
//
//   Description:
//         BtoH   ()   returns   the   equivalent   binary   value   for   an   individual
//         character   specified   in   the   ascii   format.
//
UCHAR   BtoH(char   ch)
{
        if   ((ch   > =   '0 ')   &&   (ch   <=   '9 '))
        {
                return   (ch   -   '0 ');
        }
        if   ((ch   > =   'A ')   &&   (ch   <=   'F '))
        {
                return   (ch   -   'A '   +   0xA);
        }
        if   ((ch   > =   'a ')   &&   (ch   <=   'f '))
        {
                return   (ch   -   'a '   +   0xA);
        }
        //
        //   Illegal   values   in   the   IPX   address   will   not   be   accepted
        //
        printf( "Illegal   characters   in   IPX   address!\n ");
               
        ExitProcess(-1);
}

//
//   Function:   AtoH
//
//   Description:
//         AtoH   ()   coverts   the   IPX   address   specified   in   the   string
//         (ascii)   format   to   the   binary   (hexadecimal)   format.
//
void   AtoH(char   *szDest,   char   *szSource,   int   iCount)
{
        while   (iCount--)
        {
                *szDest++   =   (BtoH(*szSource++)   < <   4)   +   BtoH(*szSource++);
        }
        return;
}


//
//   Function:   FillIpxAddress
//
//   Description:
//         FillIpxAddress()   fills   a   structure   of   type   SOCKADDR_IPX  
//         with   relevant   address-family,   network   number,   node   number  
//         and   socket   (endpoint)   parameters.
//
void   FillIpxAddress(SOCKADDR_IPX   *psa,   LPSTR   lpsAddress,   LPSTR   lpsEndpoint)
{
        LPSTR   pszPoint;                                  
   
        ZeroMemory(psa,   sizeof(SOCKADDR_IPX));
               
        psa-> sa_family   =   AF_IPX;
        //
        //   Check   if   an   address   is   specified
        //
        if   (lpsAddress   !=   NULL)
        {
                //
                //   Get   the   offset   for   node   number/network   number   separator
                //
                pszPoint   =   strchr(lpsAddress,   '. ');

                if   (pszPoint   ==   NULL)
                {
                        printf( "IPX   address   does   not   have   a   separator\n ");
                        ExitProcess(-1);
                }
                //   convert   the   address   in   the     string   format   to   binary   format
                //
                AtoH((CHAR   *)psa-> sa_netnum,     lpsAddress,   4);
                AtoH((CHAR   *)psa-> sa_nodenum,   pszPoint   +   1,   6);
        }
        if   (lpsEndpoint   !=   NULL)
        {
                psa-> sa_socket   =   (USHORT)atoi(lpsEndpoint);
        }
        return;
}

//
//   Function:   BindSocket
//
//   Description:
//         BindSocket()   binds   the   global   socket   descriptor   'sock '   to  
//         the   specified   address.   If   an   endpoint   is   specified   it   uses  
//         that   or   it   binds   to   a   system     assigned   port.
//
void   BindSocket(SOCKADDR_IPX   *psa,   LPSTR   lpsAddress,   LPSTR   lpsEndpoint)
{
        int   ret;

        //   Fill   the   givenSOCKADDR_IPX   structure
        //
        FillIpxAddress(psa,   lpsAddress,   lpsEndpoint);

        ret   =   bind(sock,   (SOCKADDR   *)   psa,   sizeof   (SOCKADDR_IPX));
        if   (ret   ==   SOCKET_ERROR)
        {
                printf( "bind()   failed:   %d\n ",   WSAGetLastError());
                return;
        }
        //   Print   the   address   we   are   bound   to.   If   a   particular   interface   is   not
        //   mentioned   in   the   BindSocket()   call,   this   may   print   the   address   as
        //   00000000.0000000000000000.   This   is   because   of   the   fact   that   an  
        //   interface   is   picked   only   when   the   actual   connection   establishment  
        //   occurs,   in   case   of   connection   oriented   socket.
        //
        printf( "Bound   to   Local   Address   -   "   );
        PrintIpxAddress(psa-> sa_netnum,   psa-> sa_nodenum);
               
        return;
}

//
//   Function:   EnumerateAdapters
//
//   Description:
//         EnumerateAdapters   ()   will   enumerate   the   available   IPX   adapters  
//         and   print   the   addresses.
//
void   EnumerateAdapters()
{
        SOCKADDR_IPX           sa_ipx;
        IPX_ADDRESS_DATA   ipx_data;
        int                             ret,  
                                          cb,  
                                          nAdapters,  
                                          i=0;
               
        //   Create   a   local   socket
        //
        chProtocol   =   'd ';
        CreateSocket();
        //
        //   Bind   to   a   local   address   and   endpoint
        //
        BindSocket   (   &sa_ipx,   NULL,   NULL   );
        //
        //   Call   getsockopt()   see   the   total   number   of   adapters
        //
        cb   =   sizeof(nAdapters);
        ret   =   getsockopt(sock,   NSPROTO_IPX,   IPX_MAX_ADAPTER_NUM,
                (CHAR   *)   &nAdapters,   &cb);
        if   (ret   ==   SOCKET_ERROR)
        {
                printf( "getsockopt(IPX_MAX_ADAPTER_NUM)   failed:   %d\n ",
                        WSAGetLastError());
                return;
        }
        printf( "Total   number   of   adapters   ->   %d\n ",   nAdapters);
        //
        //   Get   the   address   of   each   adapter
        //
        for(i=0;   i   <   nAdapters   ;i++)
        {                                                                                                
                memset   (&ipx_data,   0,   sizeof(ipx_data));
                ipx_data.adapternum   =   i;
                cb   =   sizeof(ipx_data);
                                               
                ret   =   getsockopt(sock,   NSPROTO_IPX,   IPX_ADDRESS,  
                        (CHAR   *)   &ipx_data,   &cb);
                if   (ret   ==   SOCKET_ERROR)
                {
                        printf( "getsockopt(IPX_ADDRESS)   failed:   %d\n ",
                                WSAGetLastError());
                        return;
                }
                //   Print   each   address
                //
                PrintIpxAddress(ipx_data.netnum,   ipx_data.nodenum);
        }
        return;
}

//
//   SendData()   is   generic   rotuine   to   send   some   data   over   a  
//   connection-oriented   IPX   socket.
//
int   SendData(SOCKET   s,   char   *pchBuffer)
{
        int   ret;
               
        ret   =   send(s,   pchBuffer,   strlen(pchBuffer),   0);
        if   (ret   ==   SOCKET_ERROR)
        {
                printf( "send()   failed:   %d\n ",   WSAGetLastError());
                return   -1;
        }
        return   ret;
}

//
//   ReceiveData()   is   generic   rotuine   to   receive   some   data   over   a  
//   connection-oriented   IPX   socket.
//
int   ReceiveData(SOCKET   s,   char   *pchBuffer)
{
        int   ret,
                iTotal=0,
                iLeft=dwNumBytes;
                               
        while(iLeft   >   0)
        {
                ret   =   recv(s,   &pchBuffer[iTotal],   iLeft,   0);
                if   (ret   ==   SOCKET_ERROR)
                {
                        if   (WSAGetLastError()   ==   WSAEWOULDBLOCK)
                                break;
                        printf( "recv()   failed:   %d\n ",   WSAGetLastError());
                        return   -1;
                }
                if   (ret   ==   0)
                        break;
                iTotal   +=   ret;
                iLeft     -=   ret;
        }
        return   iTotal;
}

//
//   SendDatagram()   is   generic   rotuine   to   send   a   datagram   to   a
//   specifid   host.
//
int   SendDatagram(SOCKET   s,   char   *pchBuffer,   SOCKADDR_IPX   *psa)
{
        int   ret;

        ret   =   sendto(s,   pchBuffer,   strlen   (   pchBuffer   ),   0,  
                (SOCKADDR   *)psa,   sizeof(SOCKADDR_IPX   ));
        if   (ret   ==   SOCKET_ERROR)
        {
                printf( "sendto()   failed:   %d\n ",   WSAGetLastError());
                return   -1;
        }
        return   ret;          
  }

//
//   ReceiveDatagram()   is   generic   rotuine   to   receive   a   datagram   from   a
//   specifid   host.
//
int   ReceiveDatagram(SOCKET   s,   char   *pchBuffer,   SOCKADDR_IPX   *psa,
        int   *pcb)
{
        int   ret;
       
        ret   =   recvfrom(s,   pchBuffer,   MAX_DATA_LEN,   0,   (SOCKADDR   *)   psa,
                pcb);
        if   (ret   ==   SOCKET_ERROR)
        {
                printf( "recvfrom()   failed:   %d\n ",   WSAGetLastError());
                return   -1;
        }
        return   ret;
}

//
//   Server   ()   performs   the   connection-less/connection-oriented   server
//   related   tasks
//
void   Server()
{                                                
        SOCKADDR_IPX     sa_ipx,                                   //   Server   address
                                    sa_ipx_client;                     //   Client   address  
        char                     chBuffer[MAX_DATA_LEN];   //   Data   buffer
        int                       ret,  
                                    cb;
               
        CreateSocket   (   );
        //
        //   Bind   to   a   local   address   and   endpoint
        //
        BindSocket(&sa_ipx,   pszLocalAddress,   pszServerEndpoint);
        //
        //   Check   the   Specified   protocol.   Call   listen(),   accept()   if   a   connection  
        //   oriented   protocol   is   specified
        //
        if   (chProtocol   !=   'd ')
        {
                ret   =   listen(sock,   5);
                if   (ret   ==   SOCKET_ERROR)
                {
                        printf( "listen()   failed:   %d\n ",   WSAGetLastError());
                        return;
                }
                printf( "Waiting   for   a   Connection...\n ");
                //
                //   Wait   for   a   connection
                //
while   (1)
{
                        cb   =   sizeof(sa_ipx_client);
                        newsock   =   accept(sock,   (SOCKADDR   *)   &sa_ipx_client,   &cb);

                        if   (newsock   ==   INVALID_SOCKET)
                        {
                                printf( "accept()   failed:   %d\n ",   WSAGetLastError());
                                return;
                        }
                        //   Print   the   address   of   connected   client
                        //
                        printf( "Connected   to   Client   Address   -   ");
                        PrintIpxAddress(sa_ipx_client.sa_netnum,   sa_ipx_client.sa_nodenum);

                        while   (1)
                        {
                                //   Receive   data   on   newly   created   socket
                                //
                                ret   =   ReceiveData(newsock,   chBuffer);
                                if   (ret   ==   0)
                                        break;
                                else   if   (ret   ==   -1)
                                        return;                                
                                //
                                //   Print   the   contents   of   received   data
                                //
                                chBuffer[ret]   =   '\0 ';
                                printf( "%d   bytes   of   data   received-> %s\n ",   ret,   chBuffer);
                                //
                                //   Send   data   on   newly   created   socket
                                //
                                ret   =   SendData(newsock,   chBuffer);
                                if   (ret   ==   0)
                                        break;
                                else   if   (ret   ==   -1)
                                        return;
                                printf( "%d   bytes   of   data   sent\n ",   ret);
                        }
        closesocket(newsock);
                }
        }
        else     //   Server   will   recv   and   send   datagrams
        {
                //   Receive   a   datagram   on   the   bound   socket
                //
                while   (1)
                {
                        cb   =   sizeof   (sa_ipx_client);
                        ret   =   ReceiveDatagram(sock,   chBuffer,   &sa_ipx_client,   &cb);
                        if   (ret   ==   -1)
                                return;
                        //
                        //   Print   the   contents   of   received   datagram   and   the   senders   address
                        //
                        printf( "Message   Received   from   Client   Address   -   ");
                        PrintIpxAddress(   sa_ipx_client.sa_netnum,   sa_ipx_client.sa_nodenum   );
                        chBuffer[ret]   =   '\0 ';

                        printf( "%d   bytes   of   data   received-> %s\n ",   ret,   chBuffer);
                        //
                        //   Echo   the   datagram   on   the   bound   socket   to   the   client
                        //
                        ret   =   SendDatagram(sock,   chBuffer,   &sa_ipx_client);
                        if   (ret   ==   -1)
                                return;
                        printf( "%d   bytes   of   data   sent\n ",   ret);
                }
closesocket(newsock);
        }
        return;
}

//
//   Client   ()   performs   the   connection-less/connection-oriented   client
//   related   tasks
//
void   Client()
{                                                                                                
        SOCKADDR_IPX     sa_ipx,                                   //   client   address
                                    sa_ipx_server;                     //   server   address  
        char                     chBuffer[MAX_DATA_LEN];   //   data   buffer  
        int                       ret,  
                                    cb;
        DWORD                   i;
               
        CreateSocket();
        //
        //   Bind   to   a   local   address   and   endpoint
        //
        BindSocket(&sa_ipx,   pszLocalAddress,   NULL);
       
        if   (pszServerEndpoint   ==   NULL)
        {
                printf( "Server   Endpoint   must   be   specified....Exiting\n ");
                ExitProcess(-1);
        }
        //   Fill   the   sa_ipx_server   address   address   with   server   address   and   endpoint
        //
        if   (pszServerAddress   !=   NULL)
        {
                FillIpxAddress   (   &sa_ipx_server,   pszServerAddress,   pszServerEndpoint);
        }
        else
        {
                printf( "Server   Address   must   be   specified....Exiting\n ");
                ExitProcess(-1);
        }
        //   Check   the   Specified   protocol.   Call   connect()   if   a   connection   oriented  
        //   protocol   is   specified
        //
        if   (chProtocol   !=   'd ')
        {
                printf( "Connecting   to   Server   - ");
                PrintIpxAddress   (   sa_ipx_server.sa_netnum,   sa_ipx_server.sa_nodenum   );
                //
                //   Connect   to   the   server
                //
                ret   =   connect(sock,   (SOCKADDR   *)   &sa_ipx_server,   sizeof   sa_ipx_server);
                if   (ret   ==   SOCKET_ERROR)
                {
                        printf( "connect()   failed:   %d\n ",   WSAGetLastError());
                        return;
                }
                printf( "Connected   to   Server   Address   -   ");
                PrintIpxAddress(   sa_ipx_server.sa_netnum,   sa_ipx_server.sa_nodenum   );
                //
                //   Send   data   to   the   specfied   server
                //
                memset(chBuffer,   '* ',   dwNumBytes);
                chBuffer[dwNumBytes]   =   0;

for(i=0;   i   <   dwNumToSend   ;i++)
{
                        ret   =   SendData(sock,   chBuffer);
                        if   (ret   ==   0)
                                return;
                        else   if   (ret   ==   -1)
                                return;
                        printf( "%d   bytes   of   data   sent\n ",   ret);
                        //
                        //   Receive   data   from   the   server
                        //
                        ret   =   ReceiveData(sock,   chBuffer);
                        if   (ret   ==   0)
                                return;
                        else   if   (ret   ==   -1)
                                return;
                        //
                        //   Print   the   contents   of   received   data
                        //
                        chBuffer[ret]   =   '\0 ';
                        printf( "%d   bytes   of   data   received-> %s\n ",   ret,   chBuffer);
}
        }
        else
        {
                //   Send   a   datagram   to   the   specified   server
                //
                memset(chBuffer,   '* ',   dwNumBytes);
                chBuffer[dwNumBytes]   =   0;

for(i=0;   i   <   dwNumToSend   ;i++)
{
                        ret   =   SendDatagram(sock,   chBuffer,   &sa_ipx_server);
                        if   (ret   ==   -1)
                                return;
                        printf( "%d   bytes   of   data   sent\n ",   ret);
                        //
                        //   Receive   a   datagram   from   the   server
                        //
                        cb   =   sizeof(sa_ipx_server);
                        ret   =   ReceiveDatagram(sock,   chBuffer,   &sa_ipx_server,   &cb);
                        if   (ret   ==   -1)
                                return;
                        //
                        //   Print   the   contents   of   received   data
                        //
                        chBuffer[ret]   =   '\0 ';
                        printf( "%d   bytes   of   data   received-> %s\n ",   ret,   chBuffer);
}
        }
        return;
}

//
//   Function:   CheckProtocol
//
//   Description:
//         CheckProtocol()   checks   if   a   valid   protocol   is   specified   on  
//         the   command   line.
//
BOOL   CheckProtocol(char   chProtocol)
{
        if   (( 'd '   !=   chProtocol)   &&   ( 's '   !=   chProtocol)   &&  
                ( 'p '   !=   chProtocol))
        {
                return   FALSE;
        }
        return   TRUE;
}

//
//   Function:   ValidateArgs
//
//   Description:
//         Parses   the   command   line   arguments   and   sets   some   global
//         variables   to   determine   the   behavior   of   the   application.
//
void   ValidateArgs(int   argc,   char   **argv)
{
        int       i;
               
        for   (i=1;   i   <   argc   ;i++)  
        {
                if   ((argv[i][0]   ==   '- ')   ||   (argv[i][0]   ==   '/ '   ))  
                {
                        switch   (tolower   (argv[i][1]))  
                        {
                case   's ':               //   act   as   server
                                        bServer   =   TRUE;
                        break;
                                case   'c ':               //   act   as   client
                        bServer   =   FALSE;
                                        break;
                case   'e ':               //   server   endpoint
                                        pszServerEndpoint   =   &argv[i][3];      
                        break;
                                case   'n ':               //   server   address
                        pszServerAddress   =   &argv[i][3];        
                                        break;
                case   'l ':               //   local   address
                                        pszLocalAddress   =   &argv[i][3];          
                        break;
                                case   'm ':               //   enumerate   local   addrs
                        bEnumerate   =   TRUE;                              
                                        break;
                                case   'p ':               //   protocol
                        chProtocol   =   tolower(argv[i][3]);
                                        if   (CheckProtocol(chProtocol)   ==   FALSE)
                        {
                                                printf( "Unknown   protcol   specified\n\n ");
                usage(argv[0]);
                                        }
                        break;
                                case   'b ':               //   number   of   bytes   to   send
                                        dwNumBytes   =   atoi(&argv[i][3]);
                                        break;
case   'r ': //   number   of   repititions
        dwNumToSend   =   atoi(&argv[i][3]);
        break;
                                default:
                                        usage(argv[0]);
                                        break;
                        }
                }
                else
                        usage(argv[0]);
        }        
        return;
}

//
//   Function:   main
//
//   Description:
//         The   main   function   which   loads   Winsock,   parses   the   command   line,
//         and   initiates   either   the   client   or   server   routine   depending
//         on   the   parameters   passed.
//
int   main(int   argc,   char   **argv)
{
        WSADATA                 wsd;
               
        ValidateArgs(argc,   argv);

        if   (WSAStartup(MAKEWORD(2,2),   &wsd)   !=   0)
        {
                printf( "WSAStartup()   failed:   %d\n ",   GetLastError());
                return   -1;
        }
        //   Check   to   see   if   the   role   of   the   application   is   to   enumerate   local  
        //   adapters
        //
        if   (bEnumerate)
                EnumerateAdapters();
        else
        {
                if   (bServer)                 //   Act   as   server
                        Server();
                else                                 //   Act   as   client
                        Client();
        }
        closesocket(sock);
        closesocket(newsock);

        WSACleanup();
        return   0;
}