Actual source code: client.c

      1: #include <petscwebclient.h>
      2: PETSC_PRAGMA_DIAGNOSTIC_IGNORED_BEGIN("-Wdeprecated-declarations")

      4: static BIO *bio_err = NULL;

      6: #define PASSWORD "password"

      8: #if defined(PETSC_USE_SSL_CERTIFICATE)
      9: static int password_cb(char *buf, int num, int rwflag, void *userdata)
     10: {
     11:   if (num < strlen(PASSWORD) + 1) return 0;
     12:   strcpy(buf, PASSWORD);
     13:   return strlen(PASSWORD);
     14: }
     15: #endif

     17: static void sigpipe_handle(int x) { }

     19: /*@C
     20:   PetscSSLInitializeContext - Set up an SSL context suitable for initiating HTTPS requests.

     22:   Output Parameter:
     23: . octx - the SSL_CTX to be passed to `PetscHTTPSConnect90`

     25:   Level: advanced

     27:     If PETSc was ./configure -with-ssl-certificate requires the user have created a self-signed certificate with
     28: .vb
     29:     saws/CA.pl  -newcert  (using the passphrase of password)
     30:     cat newkey.pem newcert.pem > sslclient.pem
     31: .ve

     33:   and put the resulting file in either the current directory (with the application) or in the home directory. This seems kind of
     34:   silly but it was all I could figure out.

     36: .seealso: `PetscSSLDestroyContext()`, `PetscHTTPSConnect()`, `PetscHTTPSRequest()`
     37: @*/
     38: PetscErrorCode PetscSSLInitializeContext(SSL_CTX **octx)
     39: {
     40:   SSL_CTX *ctx;
     41: #if defined(PETSC_USE_SSL_CERTIFICATE)
     42:   char      keyfile[PETSC_MAX_PATH_LEN];
     43:   PetscBool exists;
     44: #endif

     46:   PetscFunctionBegin;
     47:   if (!bio_err) {
     48:     SSL_library_init();
     49:     SSL_load_error_strings();
     50:     bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
     51:   }

     53:   /* Set up a SIGPIPE handler */
     54:   signal(SIGPIPE, sigpipe_handle);

     56: /* suggested at https://mta.openssl.org/pipermail/openssl-dev/2015-May/001449.html */
     57: #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
     58:   ctx = SSL_CTX_new(TLS_client_method());
     59: #else
     60:   ctx = SSL_CTX_new(SSLv23_client_method());
     61: #endif
     62:   SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);

     64: #if defined(PETSC_USE_SSL_CERTIFICATE)
     65:   /* Locate keyfile */
     66:   PetscCall(PetscStrncpy(keyfile, "sslclient.pem", sizeof(keyfile)));
     67:   PetscCall(PetscTestFile(keyfile, 'r', &exists));
     68:   if (!exists) {
     69:     PetscCall(PetscGetHomeDirectory(keyfile, PETSC_MAX_PATH_LEN));
     70:     PetscCall(PetscStrlcat(keyfile, "/", sizeof(keyfile)));
     71:     PetscCall(PetscStrlcat(keyfile, "sslclient.pem", sizeof(keyfile)));
     72:     PetscCall(PetscTestFile(keyfile, 'r', &exists));
     73:     PetscCheck(exists, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Unable to locate sslclient.pem file in current directory or home directory");
     74:   }

     76:   /* Load our keys and certificates*/
     77:   PetscCheck(SSL_CTX_use_certificate_chain_file(ctx, keyfile), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read certificate file");

     79:   SSL_CTX_set_default_passwd_cb(ctx, password_cb);
     80:   PetscCheck(SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read key file");
     81: #endif

     83:   *octx = ctx;
     84:   PetscFunctionReturn(PETSC_SUCCESS);
     85: }

     87: /*@C
     88:   PetscSSLDestroyContext - frees a `SSL_CTX` obtained with `PetscSSLInitializeContext()`

     90:   Input Parameter:
     91: . ctx - the `SSL_CTX`

     93:   Level: advanced

     95: .seealso: `PetscSSLInitializeContext()`, `PetscHTTPSConnect()`
     96: @*/
     97: PetscErrorCode PetscSSLDestroyContext(SSL_CTX *ctx)
     98: {
     99:   PetscFunctionBegin;
    100:   SSL_CTX_free(ctx);
    101:   PetscFunctionReturn(PETSC_SUCCESS);
    102: }

    104: static PetscErrorCode PetscHTTPBuildRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], char **outrequest)
    105: {
    106:   char     *request = 0;
    107:   char      contentlength[40], contenttype[80], *path, *host;
    108:   size_t    request_len, headlen, bodylen, contentlen, pathlen, hostlen, typelen, contenttypelen = 0;
    109:   PetscBool flg;

    111:   PetscFunctionBegin;
    112:   PetscCall(PetscStrallocpy(url, &host));
    113:   PetscCall(PetscStrchr(host, '/', &path));
    114:   PetscCheck(path, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "URL must contain /, it is %s", url);
    115:   *path = 0;
    116:   PetscCall(PetscStrlen(host, &hostlen));

    118:   PetscCall(PetscStrchr(url, '/', &path));
    119:   PetscCall(PetscStrlen(path, &pathlen));

    121:   if (header) {
    122:     PetscCall(PetscStrendswith(header, "\r\n", &flg));
    123:     PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "Header must end with \\r\\n, it is %s", header);
    124:   }

    126:   PetscCall(PetscStrlen(type, &typelen));
    127:   if (ctype) {
    128:     PetscCall(PetscSNPrintf(contenttype, 80, "Content-Type: %s\r\n", ctype));
    129:     PetscCall(PetscStrlen(contenttype, &contenttypelen));
    130:   }
    131:   PetscCall(PetscStrlen(header, &headlen));
    132:   PetscCall(PetscStrlen(body, &bodylen));
    133:   PetscCall(PetscSNPrintf(contentlength, 40, "Content-Length: %d\r\n\r\n", (int)bodylen));
    134:   PetscCall(PetscStrlen(contentlength, &contentlen));

    136:   /* Now construct our HTTP request */
    137:   request_len = typelen + 1 + pathlen + hostlen + 100 + headlen + contenttypelen + contentlen + bodylen + 1;
    138:   PetscCall(PetscMalloc1(request_len, &request));
    139:   PetscCall(PetscStrncpy(request, type, request_len));
    140:   PetscCall(PetscStrlcat(request, " ", request_len));
    141:   PetscCall(PetscStrlcat(request, path, request_len));
    142:   PetscCall(PetscStrlcat(request, " HTTP/1.1\r\nHost: ", request_len));
    143:   PetscCall(PetscStrlcat(request, host, request_len));
    144:   PetscCall(PetscFree(host));
    145:   PetscCall(PetscStrlcat(request, "\r\nUser-Agent:PETScClient\r\n", request_len));
    146:   PetscCall(PetscStrlcat(request, header, request_len));
    147:   if (ctype) PetscCall(PetscStrlcat(request, contenttype, request_len));
    148:   PetscCall(PetscStrlcat(request, contentlength, request_len));
    149:   PetscCall(PetscStrlcat(request, body, request_len));
    150:   PetscCall(PetscStrlen(request, &request_len));
    151:   PetscCall(PetscInfo(NULL, "HTTPS request follows: \n%s\n", request));

    153:   *outrequest = request;
    154:   PetscFunctionReturn(PETSC_SUCCESS);
    155: }

    157: /*@C
    158:   PetscHTTPSRequest - Send a request to an HTTPS server

    160:   Input Parameters:
    161: + type     - either "POST" or "GET"
    162: . url      - URL of request host/path
    163: . header   - additional header information, may be `NULL`
    164: . ctype    - data type of body, for example application/json
    165: . body     - data to send to server
    166: . ssl      - obtained with `PetscHTTPSConnect()`
    167: - buffsize - size of buffer

    169:   Output Parameter:
    170: . buff - everything returned from server

    172:   Level: advanced

    174: .seealso: `PetscHTTPRequest()`, `PetscHTTPSConnect()`, `PetscSSLInitializeContext()`, `PetscSSLDestroyContext()`, `PetscPullJSONValue()`
    175: @*/
    176: PetscErrorCode PetscHTTPSRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], SSL *ssl, char buff[], size_t buffsize)
    177: {
    178:   char     *request;
    179:   int       r;
    180:   size_t    request_len, len;
    181:   PetscBool foundbody = PETSC_FALSE;

    183:   PetscFunctionBegin;
    184:   PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
    185:   PetscCall(PetscStrlen(request, &request_len));

    187:   r = SSL_write(ssl, request, (int)request_len);
    188:   switch (SSL_get_error(ssl, r)) {
    189:   case SSL_ERROR_NONE:
    190:     PetscCheck(request_len == (size_t)r, PETSC_COMM_SELF, PETSC_ERR_LIB, "Incomplete write to SSL socket");
    191:     break;
    192:   default:
    193:     SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL socket write problem");
    194:   }

    196:   /* Now read the server's response, globus sends it in two chunks hence must read a second time if needed */
    197:   PetscCall(PetscArrayzero(buff, buffsize));
    198:   len       = 0;
    199:   foundbody = PETSC_FALSE;
    200:   do {
    201:     char  *clen;
    202:     int    cl;
    203:     size_t nlen;

    205:     r = SSL_read(ssl, buff + len, (int)buffsize);
    206:     len += r;
    207:     switch (SSL_get_error(ssl, r)) {
    208:     case SSL_ERROR_NONE:
    209:       break;
    210:     case SSL_ERROR_ZERO_RETURN:
    211:       foundbody = PETSC_TRUE;
    212:       SSL_shutdown(ssl);
    213:       break;
    214:     case SSL_ERROR_SYSCALL:
    215:       foundbody = PETSC_TRUE;
    216:       break;
    217:     default:
    218:       SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL read problem");
    219:     }

    221:     PetscCall(PetscStrstr(buff, "Content-Length: ", &clen));
    222:     if (clen) {
    223:       clen += 15;
    224:       sscanf(clen, "%d", &cl);
    225:       if (!cl) foundbody = PETSC_TRUE;
    226:       else {
    227:         PetscCall(PetscStrstr(buff, "\r\n\r\n", &clen));
    228:         if (clen) {
    229:           PetscCall(PetscStrlen(clen, &nlen));
    230:           if (nlen - 4 == (size_t)cl) foundbody = PETSC_TRUE;
    231:         }
    232:       }
    233:     } else {
    234:       /* if no content length than must leave because you don't know if you can read again */
    235:       foundbody = PETSC_TRUE;
    236:     }
    237:   } while (!foundbody);
    238:   PetscCall(PetscInfo(NULL, "HTTPS result follows: \n%s\n", buff));

    240:   SSL_free(ssl);
    241:   PetscCall(PetscFree(request));
    242:   PetscFunctionReturn(PETSC_SUCCESS);
    243: }

    245: /*@C
    246:   PetscHTTPRequest - Send a request to an HTTP server

    248:   Input Parameters:
    249: + type     - either "POST" or "GET"
    250: . url      - URL of request host/path
    251: . header   - additional header information, may be `NULL`
    252: . ctype    - data type of body, for example application/json
    253: . body     - data to send to server
    254: . sock     - obtained with `PetscOpenSocket()`
    255: - buffsize - size of buffer

    257:   Output Parameter:
    258: . buff - everything returned from server

    260:   Level: advanced

    262: .seealso: `PetscHTTPSRequest()`, `PetscOpenSocket()`, `PetscHTTPSConnect()`, `PetscPullJSONValue()`
    263: @*/
    264: PetscErrorCode PetscHTTPRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], int sock, char buff[], size_t buffsize)
    265: {
    266:   char  *request;
    267:   size_t request_len;

    269:   PetscFunctionBegin;
    270:   PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
    271:   PetscCall(PetscStrlen(request, &request_len));

    273:   PetscCall(PetscBinaryWrite(sock, request, request_len, PETSC_CHAR));
    274:   PetscCall(PetscFree(request));
    275:   PetscCall(PetscBinaryRead(sock, buff, buffsize, NULL, PETSC_CHAR));
    276:   buff[buffsize - 1] = 0;
    277:   PetscCall(PetscInfo(NULL, "HTTP result follows: \n%s\n", buff));
    278:   PetscFunctionReturn(PETSC_SUCCESS);
    279: }

    281: /*@C
    282:   PetscHTTPSConnect - connect to a HTTPS server

    284:   Input Parameters:
    285: + host - the name of the machine hosting the HTTPS server
    286: . port - the port number where the server is hosting, usually 443
    287: - ctx  - value obtained with `PetscSSLInitializeContext()`

    289:   Output Parameters:
    290: + sock - socket to connect
    291: - ssl  - the argument passed to `PetscHTTPSRequest()`

    293:   Level: advanced

    295: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`
    296: @*/
    297: PetscErrorCode PetscHTTPSConnect(const char host[], int port, SSL_CTX *ctx, int *sock, SSL **ssl)
    298: {
    299:   BIO *sbio;

    301:   PetscFunctionBegin;
    302:   /* Connect the TCP socket*/
    303:   PetscCall(PetscOpenSocket(host, port, sock));

    305:   /* Connect the SSL socket */
    306:   *ssl = SSL_new(ctx);
    307:   sbio = BIO_new_socket(*sock, BIO_NOCLOSE);
    308:   SSL_set_bio(*ssl, sbio, sbio);
    309:   PetscCheck(SSL_connect(*ssl) > 0, PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL connect error");
    310:   PetscFunctionReturn(PETSC_SUCCESS);
    311: }

    313: /*@C
    314:   PetscPullJSONValue - Given a JSON response containing the substring with "key" : "value"  where there may or not be spaces around the : returns the value.

    316:   Input Parameters:
    317: + buff     - the char array containing the possible values
    318: . key      - the key of the requested value
    319: - valuelen - the length of the array to contain the value associated with the key

    321:   Output Parameters:
    322: + value - the value obtained
    323: - found - flag indicating if the value was found in the buff

    325:   Level: advanced

    327: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPushJSONValue()`
    328: @*/
    329: PetscErrorCode PetscPullJSONValue(const char buff[], const char key[], char value[], size_t valuelen, PetscBool *found)
    330: {
    331:   char  *v, *w;
    332:   char   work[256];
    333:   size_t len;

    335:   PetscFunctionBegin;
    336:   PetscCall(PetscStrncpy(work, "\"", sizeof(work)));
    337:   PetscCall(PetscStrlcat(work, key, sizeof(work)));
    338:   PetscCall(PetscStrlcat(work, "\":", sizeof(work)));
    339:   PetscCall(PetscStrstr(buff, work, &v));
    340:   PetscCall(PetscStrlen(work, &len));
    341:   if (v) {
    342:     v += len;
    343:   } else {
    344:     work[len++ - 1] = 0;
    345:     PetscCall(PetscStrlcat(work, " :", sizeof(work)));
    346:     PetscCall(PetscStrstr(buff, work, &v));
    347:     if (!v) {
    348:       *found = PETSC_FALSE;
    349:       PetscFunctionReturn(PETSC_SUCCESS);
    350:     }
    351:     v += len;
    352:   }
    353:   PetscCall(PetscStrchr(v, '\"', &v));
    354:   if (!v) {
    355:     *found = PETSC_FALSE;
    356:     PetscFunctionReturn(PETSC_SUCCESS);
    357:   }
    358:   PetscCall(PetscStrchr(v + 1, '\"', &w));
    359:   if (!w) {
    360:     *found = PETSC_FALSE;
    361:     PetscFunctionReturn(PETSC_SUCCESS);
    362:   }
    363:   *found = PETSC_TRUE;
    364:   PetscCall(PetscStrncpy(value, v + 1, PetscMin((size_t)(w - v), valuelen)));
    365:   PetscFunctionReturn(PETSC_SUCCESS);
    366: }

    368: #include <ctype.h>

    370: /*@C
    371:   PetscPushJSONValue -  Puts a "key" : "value" pair onto a string

    373:   Input Parameters:
    374: + buff    - the char array where the value will be put
    375: . key     - the key value to be set
    376: . value   - the value associated with the key
    377: - bufflen - the size of the buffer (currently ignored)

    379:   Level: advanced

    381:   Note:
    382:   Ignores lengths so can cause buffer overflow

    384: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPullJSONValue()`
    385: @*/
    386: PetscErrorCode PetscPushJSONValue(char buff[], const char key[], const char value[], size_t bufflen)
    387: {
    388:   size_t    len;
    389:   PetscBool special;

    391:   PetscFunctionBegin;
    392:   PetscCall(PetscStrcmp(value, "null", &special));
    393:   if (!special) PetscCall(PetscStrcmp(value, "true", &special));
    394:   if (!special) PetscCall(PetscStrcmp(value, "false", &special));
    395:   if (!special) {
    396:     PetscInt i;

    398:     PetscCall(PetscStrlen(value, &len));
    399:     special = PETSC_TRUE;
    400:     for (i = 0; i < (int)len; i++) {
    401:       if (!isdigit(value[i])) {
    402:         special = PETSC_FALSE;
    403:         break;
    404:       }
    405:     }
    406:   }

    408:   PetscCall(PetscStrlcat(buff, "\"", bufflen));
    409:   PetscCall(PetscStrlcat(buff, key, bufflen));
    410:   PetscCall(PetscStrlcat(buff, "\":", bufflen));
    411:   if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
    412:   PetscCall(PetscStrlcat(buff, value, bufflen));
    413:   if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
    414:   PetscFunctionReturn(PETSC_SUCCESS);
    415: }