Date: 2022-03-04T17:36:57+00:00

Actual source code: send.c

      2: #include <petscsys.h>

      4: #if defined(PETSC_NEEDS_UTYPE_TYPEDEFS)
      5: /* Some systems have inconsistent include files that use but do not
      6:    ensure that the following definitions are made */
      7: typedef unsigned char   u_char;
      8: typedef unsigned short  u_short;
      9: typedef unsigned short  ushort;
     10: typedef unsigned int    u_int;
     11: typedef unsigned long   u_long;
     12: #endif

     14: #include <errno.h>
     15: #include <ctype.h>
     16: #if defined(PETSC_HAVE_MACHINE_ENDIAN_H)
     17: #include <machine/endian.h>
     18: #endif
     19: #if defined(PETSC_HAVE_UNISTD_H)
     20: #include <unistd.h>
     21: #endif
     22: #if defined(PETSC_HAVE_SYS_SOCKET_H)
     23: #include <sys/socket.h>
     24: #endif
     25: #if defined(PETSC_HAVE_SYS_WAIT_H)
     26: #include <sys/wait.h>
     27: #endif
     28: #if defined(PETSC_HAVE_NETINET_IN_H)
     29: #include <netinet/in.h>
     30: #endif
     31: #if defined(PETSC_HAVE_NETDB_H)
     32: #include <netdb.h>
     33: #endif
     34: #if defined(PETSC_HAVE_FCNTL_H)
     35: #include <fcntl.h>
     36: #endif
     37: #if defined(PETSC_HAVE_IO_H)
     38: #include <io.h>
     39: #endif
     40: #if defined(PETSC_HAVE_WINSOCK2_H)
     41: #include <Winsock2.h>
     42: #endif
     43: #include <sys/stat.h>
     44: #include <../src/sys/classes/viewer/impls/socket/socket.h>

     46: #if defined(PETSC_NEED_CLOSE_PROTO)
     47: PETSC_EXTERN int close(int);
     48: #endif
     49: #if defined(PETSC_NEED_SOCKET_PROTO)
     50: PETSC_EXTERN int socket(int,int,int);
     51: #endif
     52: #if defined(PETSC_NEED_SLEEP_PROTO)
     53: PETSC_EXTERN int sleep(unsigned);
     54: #endif
     55: #if defined(PETSC_NEED_CONNECT_PROTO)
     56: PETSC_EXTERN int connect(int,struct sockaddr*,int);
     57: #endif

     59: /*--------------------------------------------------------------*/
     60: static PetscErrorCode PetscViewerDestroy_Socket(PetscViewer viewer)
     61: {
     62:   PetscViewer_Socket *vmatlab = (PetscViewer_Socket*)viewer->data;
     63:   PetscErrorCode     ierr;

     66:   if (vmatlab->port) {
     67: #if defined(PETSC_HAVE_CLOSESOCKET)
     68:     closesocket(vmatlab->port);
     69: #else
     70:     close(vmatlab->port);
     71: #endif
     72:     if (ierr) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"System error closing socket");
     73:   }
     74:   PetscFree(vmatlab);
     75:   return(0);
     76: }

     78: /*--------------------------------------------------------------*/
     79: /*@C
     80:     PetscSocketOpen - handles connected to an open port where someone is waiting.

     82:     Input Parameters:
     83: +    url - for example www.mcs.anl.gov
     84: -    portnum - for example 80

     86:     Output Parameter:
     87: .    t - the socket number

     89:     Notes:
     90:     Use close() to close the socket connection

     92:     Use read() or PetscHTTPRequest() to read from the socket

     94:     Level: advanced

     96: .seealso:   PetscSocketListen(), PetscSocketEstablish(), PetscHTTPRequest(), PetscHTTPSConnect()
     97: @*/
     98: PetscErrorCode  PetscOpenSocket(const char hostname[],int portnum,int *t)
     99: {
    100:   struct sockaddr_in sa;
    101:   struct hostent     *hp;
    102:   int                s = 0;
    103:   PetscErrorCode     ierr;
    104:   PetscBool          flg = PETSC_TRUE;
    105:   static int         refcnt = 0;

    108:   if (!(hp=gethostbyname(hostname))) {
    109:     perror("SEND: error gethostbyname: ");
    110:     SETERRQ1(PETSC_COMM_SELF,PETSC_ERR_SYS,"system error open connection to %s",hostname);
    111:   }
    112:   PetscMemzero(&sa,sizeof(sa));
    113:   PetscMemcpy(&sa.sin_addr,hp->h_addr_list[0],hp->h_length);

    115:   sa.sin_family = hp->h_addrtype;
    116:   sa.sin_port   = htons((u_short) portnum);
    117:   while (flg) {
    118:     if ((s=socket(hp->h_addrtype,SOCK_STREAM,0)) < 0) {
    119:       perror("SEND: error socket");  SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"system error");
    120:     }
    121:     if (connect(s,(struct sockaddr*)&sa,sizeof(sa)) < 0) {
    122: #if defined(PETSC_HAVE_WSAGETLASTERROR)
    123:       WSAGetLastError();
    124:       if (ierr == WSAEADDRINUSE)    (*PetscErrorPrintf)("SEND: address is in use\n");
    125:       else if (ierr == WSAEALREADY) (*PetscErrorPrintf)("SEND: socket is non-blocking \n");
    126:       else if (ierr == WSAEISCONN) {
    127:         (*PetscErrorPrintf)("SEND: socket already connected\n");
    128:         Sleep((unsigned) 1);
    129:       } else if (ierr == WSAECONNREFUSED) {
    130:         /* (*PetscErrorPrintf)("SEND: forcefully rejected\n"); */
    131:         Sleep((unsigned) 1);
    132:       } else {
    133:         perror(NULL); SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"system error");
    134:       }
    135: #else
    136:       if (errno == EADDRINUSE)    (*PetscErrorPrintf)("SEND: address is in use\n");
    137:       else if (errno == EALREADY) (*PetscErrorPrintf)("SEND: socket is non-blocking \n");
    138:       else if (errno == EISCONN) {
    139:         (*PetscErrorPrintf)("SEND: socket already connected\n");
    140:         sleep((unsigned) 1);
    141:       } else if (errno == ECONNREFUSED) {
    142:         refcnt++;
    143:         if (refcnt > 5) SETERRQ2(PETSC_COMM_SELF,PETSC_ERR_SYS,"Connection refused by remote host %s port %d",hostname,portnum);
    144:         PetscInfo(NULL,"Connection refused in attaching socket, trying again\n");
    145:         sleep((unsigned) 1);
    146:       } else {
    147:         perror(NULL); SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"system error");
    148:       }
    149: #endif
    150:       flg = PETSC_TRUE;
    151: #if defined(PETSC_HAVE_CLOSESOCKET)
    152:       closesocket(s);
    153: #else
    154:       close(s);
    155: #endif
    156:     } else flg = PETSC_FALSE;
    157:   }
    158:   *t = s;
    159:   return(0);
    160: }

    162: /*@C
    163:    PetscSocketEstablish - starts a listener on a socket

    165:    Input Parameters:
    166: .    portnumber - the port to wait at

    168:    Output Parameters:
    169: .     ss - the socket to be used with PetscSocketListen()

    171:     Level: advanced

    173: .seealso:   PetscSocketListen(), PetscOpenSocket()

    175: @*/
    176: PETSC_INTERN PetscErrorCode PetscSocketEstablish(int portnum,int *ss)
    177: {
    178:   static size_t      MAXHOSTNAME = 100;
    179:   char               myname[MAXHOSTNAME+1];
    180:   int                s;
    181:   PetscErrorCode     ierr;
    182:   struct sockaddr_in sa;
    183:   struct hostent     *hp;

    186:   PetscGetHostName(myname,sizeof(myname));

    188:   PetscMemzero(&sa,sizeof(struct sockaddr_in));

    190:   hp = gethostbyname(myname);
    191:   if (!hp) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"Unable to get hostent information from system");

    193:   sa.sin_family = hp->h_addrtype;
    194:   sa.sin_port   = htons((u_short)portnum);

    196:   if ((s = socket(AF_INET,SOCK_STREAM,0)) < 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"Error running socket() command");
    197: #if defined(PETSC_HAVE_SO_REUSEADDR)
    198:   {
    199:     int optval = 1; /* Turn on the option */
    200:     setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char*)&optval,sizeof(optval));
    201:   }
    202: #endif

    204:   while (bind(s,(struct sockaddr*)&sa,sizeof(sa)) < 0) {
    205: #if defined(PETSC_HAVE_WSAGETLASTERROR)
    206:     WSAGetLastError();
    207:     if (ierr != WSAEADDRINUSE) {
    208: #else
    209:     if (errno != EADDRINUSE) {
    210: #endif
    211:       close(s);
    212:       SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"Error from bind()");
    213:     }
    214:   }
    215:   listen(s,0);
    216:   *ss = s;
    217:   return(0);
    218: }

    220: /*@C
    221:    PetscSocketListen - Listens at a socket created with PetscSocketEstablish()

    223:    Input Parameter:
    224: .    listenport - obtained with PetscSocketEstablish()

    226:    Output Parameter:
    227: .     t - pass this to read() to read what is passed to this connection

    229:     Level: advanced

    231: .seealso:   PetscSocketEstablish()
    232: @*/
    233: PETSC_INTERN PetscErrorCode PetscSocketListen(int listenport,int *t)
    234: {
    235:   struct sockaddr_in isa;
    236: #if defined(PETSC_HAVE_ACCEPT_SIZE_T)
    237:   size_t             i;
    238: #else
    239:   int                i;
    240: #endif

    243:   /* wait for someone to try to connect */
    244:   i = sizeof(struct sockaddr_in);
    245:   if ((*t = accept(listenport,(struct sockaddr*)&isa,(socklen_t*)&i)) < 0) SETERRQ(PETSC_COMM_SELF,PETSC_ERR_SYS,"error from accept()\n");
    246:   return(0);
    247: }

    249: /*@C
    250:    PetscViewerSocketOpen - Opens a connection to a MATLAB or other socket based server.

    252:    Collective

    254:    Input Parameters:
    255: +  comm - the MPI communicator
    256: .  machine - the machine the server is running on,, use NULL for the local machine, use "server" to passively wait for
    257:              a connection from elsewhere
    258: -  port - the port to connect to, use PETSC_DEFAULT for the default

    260:    Output Parameter:
    261: .  lab - a context to use when communicating with the server

    263:    Level: intermediate

    265:    Notes:
    266:    Most users should employ the following commands to access the
    267:    MATLAB PetscViewers
    268: $
    269: $    PetscViewerSocketOpen(MPI_Comm comm, char *machine,int port,PetscViewer &viewer)
    270: $    MatView(Mat matrix,PetscViewer viewer)
    271: $
    272: $                or
    273: $
    274: $    PetscViewerSocketOpen(MPI_Comm comm,char *machine,int port,PetscViewer &viewer)
    275: $    VecView(Vec vector,PetscViewer viewer)

    277:    Options Database Keys:
    278:    For use with  PETSC_VIEWER_SOCKET_WORLD, PETSC_VIEWER_SOCKET_SELF,
    279:    PETSC_VIEWER_SOCKET_() or if
    280:     NULL is passed for machine or PETSC_DEFAULT is passed for port
    281: $    -viewer_socket_machine <machine>
    282: $    -viewer_socket_port <port>

    284:    Environmental variables:
    285: +   PETSC_VIEWER_SOCKET_PORT - portnumber
    286: -   PETSC_VIEWER_SOCKET_MACHINE - machine name

    288:      Currently the only socket client available is MATLAB. See
    289:      src/dm/tests/ex12.c and ex12.m for an example of usage.

    291:    Notes:
    292:     The socket viewer is in some sense a subclass of the binary viewer, to read and write to the socket
    293:           use PetscViewerBinaryRead(), PetscViewerBinaryWrite(), PetscViewerBinarWriteStringArray(), PetscViewerBinaryGetDescriptor().

    295:      Use this for communicating with an interactive MATLAB session, see PETSC_VIEWER_MATLAB_() for writing output to a
    296:      .mat file. Use PetscMatlabEngineCreate() or PETSC_MATLAB_ENGINE_(), PETSC_MATLAB_ENGINE_SELF, or PETSC_MATLAB_ENGINE_WORLD
    297:      for communicating with a MATLAB Engine

    299: .seealso: MatView(), VecView(), PetscViewerDestroy(), PetscViewerCreate(), PetscViewerSetType(),
    300:           PetscViewerSocketSetConnection(), PETSC_VIEWER_SOCKET_, PETSC_VIEWER_SOCKET_WORLD,
    301:           PETSC_VIEWER_SOCKET_SELF, PetscViewerBinaryWrite(), PetscViewerBinaryRead(), PetscViewerBinaryWriteStringArray(),
    302:           PetscBinaryViewerGetDescriptor(), PetscMatlabEngineCreate()
    303: @*/
    304: PetscErrorCode  PetscViewerSocketOpen(MPI_Comm comm,const char machine[],int port,PetscViewer *lab)
    305: {

    309:   PetscViewerCreate(comm,lab);
    310:   PetscViewerSetType(*lab,PETSCVIEWERSOCKET);
    311:   PetscViewerSocketSetConnection(*lab,machine,port);
    312:   return(0);
    313: }

    315: static PetscErrorCode PetscViewerSetFromOptions_Socket(PetscOptionItems *PetscOptionsObject,PetscViewer v)
    316: {
    318:   PetscInt       def = -1;
    319:   char           sdef[256];
    320:   PetscBool      tflg;

    323:   /*
    324:        These options are not processed here, they are processed in PetscViewerSocketSetConnection(), they
    325:     are listed here for the GUI to display
    326:   */
    327:   PetscOptionsHead(PetscOptionsObject,"Socket PetscViewer Options");
    328:   PetscOptionsGetenv(PetscObjectComm((PetscObject)v),"PETSC_VIEWER_SOCKET_PORT",sdef,16,&tflg);
    329:   if (tflg) {
    330:     PetscOptionsStringToInt(sdef,&def);
    331:   } else def = PETSCSOCKETDEFAULTPORT;
    332:   PetscOptionsInt("-viewer_socket_port","Port number to use for socket","PetscViewerSocketSetConnection",def,NULL,NULL);

    334:   PetscOptionsString("-viewer_socket_machine","Machine to use for socket","PetscViewerSocketSetConnection",sdef,NULL,sizeof(sdef),NULL);
    335:   PetscOptionsGetenv(PetscObjectComm((PetscObject)v),"PETSC_VIEWER_SOCKET_MACHINE",sdef,sizeof(sdef),&tflg);
    336:   if (!tflg) {
    337:     PetscGetHostName(sdef,sizeof(sdef));
    338:   }
    339:   PetscOptionsTail();
    340:   return(0);
    341: }

    343: static PetscErrorCode PetscViewerBinaryGetSkipHeader_Socket(PetscViewer viewer,PetscBool  *skip)
    344: {
    345:   PetscViewer_Socket *vsocket = (PetscViewer_Socket*)viewer->data;

    348:   *skip = vsocket->skipheader;
    349:   return(0);
    350: }

    352: static PetscErrorCode PetscViewerBinarySetSkipHeader_Socket(PetscViewer viewer,PetscBool skip)
    353: {
    354:   PetscViewer_Socket *vsocket = (PetscViewer_Socket*)viewer->data;

    357:   vsocket->skipheader = skip;
    358:   return(0);
    359: }

    361: static PetscErrorCode  PetscViewerBinaryGetFlowControl_Socket(PetscViewer viewer,PetscInt *fc)
    362: {
    364:   *fc = 0;
    365:   return(0);
    366: }

    368: /*MC
    369:    PETSCVIEWERSOCKET - A viewer that writes to a Unix socket

    371: .seealso:  PetscViewerSocketOpen(), PetscViewerDrawOpen(), PETSC_VIEWER_DRAW_(),PETSC_VIEWER_DRAW_SELF, PETSC_VIEWER_DRAW_WORLD,
    372:            PetscViewerCreate(), PetscViewerASCIIOpen(), PetscViewerBinaryOpen(), PETSCVIEWERBINARY, PETSCVIEWERDRAW,
    373:            PetscViewerMatlabOpen(), VecView(), DMView(), PetscViewerMatlabPutArray(), PETSCVIEWERASCII, PETSCVIEWERMATLAB,
    374:            PetscViewerFileSetName(), PetscViewerFileSetMode(), PetscViewerFormat, PetscViewerType, PetscViewerSetType()

    376:   Level: beginner
    377: M*/

    379: PETSC_EXTERN PetscErrorCode PetscViewerCreate_Socket(PetscViewer v)
    380: {
    381:   PetscViewer_Socket *vmatlab;
    382:   PetscErrorCode     ierr;

    385:   PetscNewLog(v,&vmatlab);
    386:   vmatlab->port          = 0;
    387:   v->data                = (void*)vmatlab;
    388:   v->ops->destroy        = PetscViewerDestroy_Socket;
    389:   v->ops->flush          = NULL;
    390:   v->ops->setfromoptions = PetscViewerSetFromOptions_Socket;

    392:   /* lie and say this is a binary viewer; then all the XXXView_Binary() methods will work correctly on it */
    393:   PetscObjectChangeTypeName((PetscObject)v,PETSCVIEWERBINARY);
    394:   PetscObjectComposeFunction((PetscObject)v,"PetscViewerBinarySetSkipHeader_C",PetscViewerBinarySetSkipHeader_Socket);
    395:   PetscObjectComposeFunction((PetscObject)v,"PetscViewerBinaryGetSkipHeader_C",PetscViewerBinaryGetSkipHeader_Socket);
    396:   PetscObjectComposeFunction((PetscObject)v,"PetscViewerBinaryGetFlowControl_C",PetscViewerBinaryGetFlowControl_Socket);

    398:   return(0);
    399: }

    401: /*@C
    402:       PetscViewerSocketSetConnection - Sets the machine and port that a PETSc socket
    403:              viewer is to use

    405:   Logically Collective on PetscViewer

    407:   Input Parameters:
    408: +   v - viewer to connect
    409: .   machine - host to connect to, use NULL for the local machine,use "server" to passively wait for
    410:              a connection from elsewhere
    411: -   port - the port on the machine one is connecting to, use PETSC_DEFAULT for default

    413:     Level: advanced

    415: .seealso: PetscViewerSocketOpen()
    416: @*/
    417: PetscErrorCode  PetscViewerSocketSetConnection(PetscViewer v,const char machine[],int port)
    418: {
    419:   PetscErrorCode     ierr;
    420:   PetscMPIInt        rank;
    421:   char               mach[256];
    422:   PetscBool          tflg;
    423:   PetscViewer_Socket *vmatlab = (PetscViewer_Socket*)v->data;

    427:   if (port <= 0) {
    428:     char portn[16];
    429:     PetscOptionsGetenv(PetscObjectComm((PetscObject)v),"PETSC_VIEWER_SOCKET_PORT",portn,16,&tflg);
    430:     if (tflg) {
    431:       PetscInt pport;
    432:       PetscOptionsStringToInt(portn,&pport);
    433:       port = (int)pport;
    434:     } else port = PETSCSOCKETDEFAULTPORT;
    435:   }
    436:   if (!machine) {
    437:     PetscOptionsGetenv(PetscObjectComm((PetscObject)v),"PETSC_VIEWER_SOCKET_MACHINE",mach,sizeof(mach),&tflg);
    438:     if (!tflg) {
    439:       PetscGetHostName(mach,sizeof(mach));
    440:     }
    441:   } else {
    442:     PetscStrncpy(mach,machine,sizeof(mach));
    443:   }

    445:   MPI_Comm_rank(PetscObjectComm((PetscObject)v),&rank);
    446:   if (rank == 0) {
    447:     PetscStrcmp(mach,"server",&tflg);
    448:     if (tflg) {
    449:       int listenport;
    450:       PetscInfo1(v,"Waiting for connection from socket process on port %D\n",port);
    451:       PetscSocketEstablish(port,&listenport);
    452:       PetscSocketListen(listenport,&vmatlab->port);
    453:       close(listenport);
    454:     } else {
    455:       PetscInfo2(v,"Connecting to socket process on port %D machine %s\n",port,mach);
    456:       PetscOpenSocket(mach,port,&vmatlab->port);
    457:     }
    458:   }
    459:   return(0);
    460: }

    462: /* ---------------------------------------------------------------------*/
    463: /*
    464:     The variable Petsc_Viewer_Socket_keyval is used to indicate an MPI attribute that
    465:   is attached to a communicator, in this case the attribute is a PetscViewer.
    466: */
    467: PetscMPIInt Petsc_Viewer_Socket_keyval = MPI_KEYVAL_INVALID;

    469: /*@C
    470:      PETSC_VIEWER_SOCKET_ - Creates a socket viewer shared by all processors in a communicator.

    472:      Collective

    474:      Input Parameter:
    475: .    comm - the MPI communicator to share the socket PetscViewer

    477:      Level: intermediate

    479:    Options Database Keys:
    480:    For use with the default PETSC_VIEWER_SOCKET_WORLD or if
    481:     NULL is passed for machine or PETSC_DEFAULT is passed for port
    482: $    -viewer_socket_machine <machine>
    483: $    -viewer_socket_port <port>

    485:    Environmental variables:
    486: +   PETSC_VIEWER_SOCKET_PORT - portnumber
    487: -   PETSC_VIEWER_SOCKET_MACHINE - machine name

    489:      Notes:
    490:      Unlike almost all other PETSc routines, Petsc_VIEWER_SOCKET_ does not return
    491:      an error code, it returns NULL if it fails. The socket PetscViewer is usually used in the form
    492: $       XXXView(XXX object,PETSC_VIEWER_SOCKET_(comm));

    494:      Currently the only socket client available is MATLAB. See
    495:      src/dm/tests/ex12.c and ex12.m for an example of usage.

    497:      Connects to a waiting socket and stays connected until PetscViewerDestroy() is called.

    499:      Use this for communicating with an interactive MATLAB session, see PETSC_VIEWER_MATLAB_() for writing output to a
    500:      .mat file. Use PetscMatlabEngineCreate() or PETSC_MATLAB_ENGINE_(), PETSC_MATLAB_ENGINE_SELF, or PETSC_MATLAB_ENGINE_WORLD
    501:      for communicating with a MATLAB Engine

    503: .seealso: PETSC_VIEWER_SOCKET_WORLD, PETSC_VIEWER_SOCKET_SELF, PetscViewerSocketOpen(), PetscViewerCreate(),
    504:           PetscViewerSocketSetConnection(), PetscViewerDestroy(), PETSC_VIEWER_SOCKET_(), PetscViewerBinaryWrite(), PetscViewerBinaryRead(),
    505:           PetscViewerBinaryWriteStringArray(), PetscViewerBinaryGetDescriptor(), PETSC_VIEWER_MATLAB_()
    506: @*/
    507: PetscViewer  PETSC_VIEWER_SOCKET_(MPI_Comm comm)
    508: {
    510:   PetscBool      flg;
    511:   PetscViewer    viewer;
    512:   MPI_Comm       ncomm;

    515:   PetscCommDuplicate(comm,&ncomm,NULL);if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," ");PetscFunctionReturn(NULL);}
    516:   if (Petsc_Viewer_Socket_keyval == MPI_KEYVAL_INVALID) {
    517:     MPI_Comm_create_keyval(MPI_COMM_NULL_COPY_FN,MPI_COMM_NULL_DELETE_FN,&Petsc_Viewer_Socket_keyval,NULL);
    518:     if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," ");PetscFunctionReturn(NULL);}
    519:   }
    520:   MPI_Comm_get_attr(ncomm,Petsc_Viewer_Socket_keyval,(void**)&viewer,(int*)&flg);
    521:   if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," ");PetscFunctionReturn(NULL);}
    522:   if (!flg) { /* PetscViewer not yet created */
    523:     PetscViewerSocketOpen(ncomm,NULL,0,&viewer);
    524:     if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_REPEAT," ");PetscFunctionReturn(NULL);}
    525:     PetscObjectRegisterDestroy((PetscObject)viewer);
    526:     if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_REPEAT," ");PetscFunctionReturn(NULL);}
    527:     MPI_Comm_set_attr(ncomm,Petsc_Viewer_Socket_keyval,(void*)viewer);
    528:     if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_INITIAL," ");PetscFunctionReturn(NULL);}
    529:   }
    530:   PetscCommDestroy(&ncomm);
    531:   if (ierr) {PetscError(PETSC_COMM_SELF,__LINE__,"PETSC_VIEWER_SOCKET_",__FILE__,PETSC_ERR_PLIB,PETSC_ERROR_REPEAT," ");PetscFunctionReturn(NULL);}
    532:   PetscFunctionReturn(viewer);
    533: }