Actual source code: client.c
2: #include <petscwebclient.h>
3: PETSC_PRAGMA_DIAGNOSTIC_IGNORED_BEGIN("-Wdeprecated-declarations")
5: static BIO *bio_err = NULL;
7: #define PASSWORD "password"
9: #if defined(PETSC_USE_SSL_CERTIFICATE)
10: static int password_cb(char *buf, int num, int rwflag, void *userdata)
11: {
12: if (num < strlen(PASSWORD) + 1) return (0);
13: strcpy(buf, PASSWORD);
14: return (strlen(PASSWORD));
15: }
16: #endif
18: static void sigpipe_handle(int x) { }
20: /*@C
21: PetscSSLInitializeContext - Set up an SSL context suitable for initiating HTTPS requests.
23: Output Parameter:
24: . octx - the SSL_CTX to be passed to `PetscHTTPSConnect90`
26: Level: advanced
28: If PETSc was ./configure -with-ssl-certificate requires the user have created a self-signed certificate with
29: .vb
30: saws/CA.pl -newcert (using the passphrase of password)
31: cat newkey.pem newcert.pem > sslclient.pem
32: .ve
34: and put the resulting file in either the current directory (with the application) or in the home directory. This seems kind of
35: silly but it was all I could figure out.
37: .seealso: `PetscSSLDestroyContext()`, `PetscHTTPSConnect()`, `PetscHTTPSRequest()`
38: @*/
39: PetscErrorCode PetscSSLInitializeContext(SSL_CTX **octx)
40: {
41: SSL_CTX *ctx;
42: #if defined(PETSC_USE_SSL_CERTIFICATE)
43: char keyfile[PETSC_MAX_PATH_LEN];
44: PetscBool exists;
45: #endif
47: PetscFunctionBegin;
48: if (!bio_err) {
49: SSL_library_init();
50: SSL_load_error_strings();
51: bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
52: }
54: /* Set up a SIGPIPE handler */
55: signal(SIGPIPE, sigpipe_handle);
57: /* suggested at https://mta.openssl.org/pipermail/openssl-dev/2015-May/001449.html */
58: #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
59: ctx = SSL_CTX_new(TLS_client_method());
60: #else
61: ctx = SSL_CTX_new(SSLv23_client_method());
62: #endif
63: SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
65: #if defined(PETSC_USE_SSL_CERTIFICATE)
66: /* Locate keyfile */
67: PetscCall(PetscStrncpy(keyfile, "sslclient.pem", sizeof(keyfile)));
68: PetscCall(PetscTestFile(keyfile, 'r', &exists));
69: if (!exists) {
70: PetscCall(PetscGetHomeDirectory(keyfile, PETSC_MAX_PATH_LEN));
71: PetscCall(PetscStrlcat(keyfile, "/", sizeof(keyfile)));
72: PetscCall(PetscStrlcat(keyfile, "sslclient.pem", sizeof(keyfile)));
73: PetscCall(PetscTestFile(keyfile, 'r', &exists));
74: PetscCheck(exists, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Unable to locate sslclient.pem file in current directory or home directory");
75: }
77: /* Load our keys and certificates*/
78: PetscCheck(SSL_CTX_use_certificate_chain_file(ctx, keyfile), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read certificate file");
80: SSL_CTX_set_default_passwd_cb(ctx, password_cb);
81: PetscCheck(SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read key file");
82: #endif
84: *octx = ctx;
85: PetscFunctionReturn(PETSC_SUCCESS);
86: }
88: /*@C
89: PetscSSLDestroyContext - frees a `SSL_CTX` obtained with `PetscSSLInitializeContext()`
91: Input Parameter:
92: . ctx - the `SSL_CTX`
94: Level: advanced
96: .seealso: `PetscSSLInitializeContext()`, `PetscHTTPSConnect()`
97: @*/
98: PetscErrorCode PetscSSLDestroyContext(SSL_CTX *ctx)
99: {
100: PetscFunctionBegin;
101: SSL_CTX_free(ctx);
102: PetscFunctionReturn(PETSC_SUCCESS);
103: }
105: static PetscErrorCode PetscHTTPBuildRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], char **outrequest)
106: {
107: char *request = 0;
108: char contentlength[40], contenttype[80], *path, *host;
109: size_t request_len, headlen, bodylen, contentlen, pathlen, hostlen, typelen, contenttypelen = 0;
110: PetscBool flg;
112: PetscFunctionBegin;
113: PetscCall(PetscStrallocpy(url, &host));
114: PetscCall(PetscStrchr(host, '/', &path));
115: PetscCheck(path, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "url must contain / it is %s", url);
116: *path = 0;
117: PetscCall(PetscStrlen(host, &hostlen));
119: PetscCall(PetscStrchr(url, '/', &path));
120: PetscCall(PetscStrlen(path, &pathlen));
122: if (header) {
123: PetscCall(PetscStrendswith(header, "\r\n", &flg));
124: PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "header must end with \\r\\n");
125: }
127: PetscCall(PetscStrlen(type, &typelen));
128: if (ctype) {
129: PetscCall(PetscSNPrintf(contenttype, 80, "Content-Type: %s\r\n", ctype));
130: PetscCall(PetscStrlen(contenttype, &contenttypelen));
131: }
132: PetscCall(PetscStrlen(header, &headlen));
133: PetscCall(PetscStrlen(body, &bodylen));
134: PetscCall(PetscSNPrintf(contentlength, 40, "Content-Length: %d\r\n\r\n", (int)bodylen));
135: PetscCall(PetscStrlen(contentlength, &contentlen));
137: /* Now construct our HTTP request */
138: request_len = typelen + 1 + pathlen + hostlen + 100 + headlen + contenttypelen + contentlen + bodylen + 1;
139: PetscCall(PetscMalloc1(request_len, &request));
140: PetscCall(PetscStrncpy(request, type, request_len));
141: PetscCall(PetscStrlcat(request, " ", request_len));
142: PetscCall(PetscStrlcat(request, path, request_len));
143: PetscCall(PetscStrlcat(request, " HTTP/1.1\r\nHost: ", request_len));
144: PetscCall(PetscStrlcat(request, host, request_len));
145: PetscCall(PetscFree(host));
146: PetscCall(PetscStrlcat(request, "\r\nUser-Agent:PETScClient\r\n", request_len));
147: PetscCall(PetscStrlcat(request, header, request_len));
148: if (ctype) PetscCall(PetscStrlcat(request, contenttype, request_len));
149: PetscCall(PetscStrlcat(request, contentlength, request_len));
150: PetscCall(PetscStrlcat(request, body, request_len));
151: PetscCall(PetscStrlen(request, &request_len));
152: PetscCall(PetscInfo(NULL, "HTTPS request follows: \n%s\n", request));
154: *outrequest = request;
155: PetscFunctionReturn(PETSC_SUCCESS);
156: }
158: /*@C
159: PetscHTTPSRequest - Send a request to an HTTPS server
161: Input Parameters:
162: + type - either "POST" or "GET"
163: . url - URL of request host/path
164: . header - additional header information, may be NULL
165: . ctype - data type of body, for example application/json
166: . body - data to send to server
167: . ssl - obtained with `PetscHTTPSConnect()`
168: - buffsize - size of buffer
170: Output Parameter:
171: . buff - everything returned from server
173: Level: advanced
175: .seealso: `PetscHTTPRequest()`, `PetscHTTPSConnect()`, `PetscSSLInitializeContext()`, `PetscSSLDestroyContext()`, `PetscPullJSONValue()`
176: @*/
177: PetscErrorCode PetscHTTPSRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], SSL *ssl, char buff[], size_t buffsize)
178: {
179: char *request;
180: int r;
181: size_t request_len, len;
182: PetscBool foundbody = PETSC_FALSE;
184: PetscFunctionBegin;
185: PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
186: PetscCall(PetscStrlen(request, &request_len));
188: r = SSL_write(ssl, request, (int)request_len);
189: switch (SSL_get_error(ssl, r)) {
190: case SSL_ERROR_NONE:
191: PetscCheck(request_len == (size_t)r, PETSC_COMM_SELF, PETSC_ERR_LIB, "Incomplete write to SSL socket");
192: break;
193: default:
194: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL socket write problem");
195: }
197: /* Now read the server's response, globus sends it in two chunks hence must read a second time if needed */
198: PetscCall(PetscArrayzero(buff, buffsize));
199: len = 0;
200: foundbody = PETSC_FALSE;
201: do {
202: char *clen;
203: int cl;
204: size_t nlen;
206: r = SSL_read(ssl, buff + len, (int)buffsize);
207: len += r;
208: switch (SSL_get_error(ssl, r)) {
209: case SSL_ERROR_NONE:
210: break;
211: case SSL_ERROR_ZERO_RETURN:
212: foundbody = PETSC_TRUE;
213: SSL_shutdown(ssl);
214: break;
215: case SSL_ERROR_SYSCALL:
216: foundbody = PETSC_TRUE;
217: break;
218: default:
219: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL read problem");
220: }
222: PetscCall(PetscStrstr(buff, "Content-Length: ", &clen));
223: if (clen) {
224: clen += 15;
225: sscanf(clen, "%d", &cl);
226: if (!cl) foundbody = PETSC_TRUE;
227: else {
228: PetscCall(PetscStrstr(buff, "\r\n\r\n", &clen));
229: if (clen) {
230: PetscCall(PetscStrlen(clen, &nlen));
231: if (nlen - 4 == (size_t)cl) foundbody = PETSC_TRUE;
232: }
233: }
234: } else {
235: /* if no content length than must leave because you don't know if you can read again */
236: foundbody = PETSC_TRUE;
237: }
238: } while (!foundbody);
239: PetscCall(PetscInfo(NULL, "HTTPS result follows: \n%s\n", buff));
241: SSL_free(ssl);
242: PetscCall(PetscFree(request));
243: PetscFunctionReturn(PETSC_SUCCESS);
244: }
246: /*@C
247: PetscHTTPRequest - Send a request to an HTTP server
249: Input Parameters:
250: + type - either "POST" or "GET"
251: . url - URL of request host/path
252: . header - additional header information, may be NULL
253: . ctype - data type of body, for example application/json
254: . body - data to send to server
255: . sock - obtained with `PetscOpenSocket()`
256: - buffsize - size of buffer
258: Output Parameter:
259: . buff - everything returned from server
261: Level: advanced
263: .seealso: `PetscHTTPSRequest()`, `PetscOpenSocket()`, `PetscHTTPSConnect()`, `PetscPullJSONValue()`
264: @*/
265: PetscErrorCode PetscHTTPRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], int sock, char buff[], size_t buffsize)
266: {
267: char *request;
268: size_t request_len;
270: PetscFunctionBegin;
271: PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
272: PetscCall(PetscStrlen(request, &request_len));
274: PetscCall(PetscBinaryWrite(sock, request, request_len, PETSC_CHAR));
275: PetscCall(PetscFree(request));
276: PetscCall(PetscBinaryRead(sock, buff, buffsize, NULL, PETSC_CHAR));
277: buff[buffsize - 1] = 0;
278: PetscCall(PetscInfo(NULL, "HTTP result follows: \n%s\n", buff));
279: PetscFunctionReturn(PETSC_SUCCESS);
280: }
282: /*@C
283: PetscHTTPSConnect - connect to a HTTPS server
285: Input Parameters:
286: + host - the name of the machine hosting the HTTPS server
287: . port - the port number where the server is hosting, usually 443
288: - ctx - value obtained with `PetscSSLInitializeContext()`
290: Output Parameters:
291: + sock - socket to connect
292: - ssl - the argument passed to `PetscHTTPSRequest()`
294: Level: advanced
296: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`
297: @*/
298: PetscErrorCode PetscHTTPSConnect(const char host[], int port, SSL_CTX *ctx, int *sock, SSL **ssl)
299: {
300: BIO *sbio;
302: PetscFunctionBegin;
303: /* Connect the TCP socket*/
304: PetscCall(PetscOpenSocket(host, port, sock));
306: /* Connect the SSL socket */
307: *ssl = SSL_new(ctx);
308: sbio = BIO_new_socket(*sock, BIO_NOCLOSE);
309: SSL_set_bio(*ssl, sbio, sbio);
310: PetscCheck(SSL_connect(*ssl) > 0, PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL connect error");
311: PetscFunctionReturn(PETSC_SUCCESS);
312: }
314: /*@C
315: PetscPullJSONValue - Given a JSON response containing the substring with "key" : "value" where there may or not be spaces around the : returns the value.
317: Input Parameters:
318: + buff - the char array containing the possible values
319: . key - the key of the requested value
320: - valuelen - the length of the array to contain the value associated with the key
322: Output Parameters:
323: + value - the value obtained
324: - found - flag indicating if the value was found in the buff
326: Level: advanced
328: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPushJSONValue()`
329: @*/
330: PetscErrorCode PetscPullJSONValue(const char buff[], const char key[], char value[], size_t valuelen, PetscBool *found)
331: {
332: char *v, *w;
333: char work[256];
334: size_t len;
336: PetscFunctionBegin;
337: PetscCall(PetscStrncpy(work, "\"", sizeof(work)));
338: PetscCall(PetscStrlcat(work, key, sizeof(work)));
339: PetscCall(PetscStrlcat(work, "\":", sizeof(work)));
340: PetscCall(PetscStrstr(buff, work, &v));
341: PetscCall(PetscStrlen(work, &len));
342: if (v) {
343: v += len;
344: } else {
345: work[len++ - 1] = 0;
346: PetscCall(PetscStrlcat(work, " :", sizeof(work)));
347: PetscCall(PetscStrstr(buff, work, &v));
348: if (!v) {
349: *found = PETSC_FALSE;
350: PetscFunctionReturn(PETSC_SUCCESS);
351: }
352: v += len;
353: }
354: PetscCall(PetscStrchr(v, '\"', &v));
355: if (!v) {
356: *found = PETSC_FALSE;
357: PetscFunctionReturn(PETSC_SUCCESS);
358: }
359: PetscCall(PetscStrchr(v + 1, '\"', &w));
360: if (!w) {
361: *found = PETSC_FALSE;
362: PetscFunctionReturn(PETSC_SUCCESS);
363: }
364: *found = PETSC_TRUE;
365: PetscCall(PetscStrncpy(value, v + 1, PetscMin((size_t)(w - v), valuelen)));
366: PetscFunctionReturn(PETSC_SUCCESS);
367: }
369: #include <ctype.h>
371: /*@C
372: PetscPushJSONValue - Puts a "key" : "value" pair onto a string
374: Input Parameters:
375: + buffer - the char array where the value will be put
376: . key - the key value to be set
377: . value - the value associated with the key
378: - bufflen - the size of the buffer (currently ignored)
380: Level: advanced
382: Note:
383: Ignores lengths so can cause buffer overflow
385: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPullJSONValue()`
386: @*/
387: PetscErrorCode PetscPushJSONValue(char buff[], const char key[], const char value[], size_t bufflen)
388: {
389: size_t len;
390: PetscBool special;
392: PetscFunctionBegin;
393: PetscCall(PetscStrcmp(value, "null", &special));
394: if (!special) PetscCall(PetscStrcmp(value, "true", &special));
395: if (!special) PetscCall(PetscStrcmp(value, "false", &special));
396: if (!special) {
397: PetscInt i;
399: PetscCall(PetscStrlen(value, &len));
400: special = PETSC_TRUE;
401: for (i = 0; i < (int)len; i++) {
402: if (!isdigit(value[i])) {
403: special = PETSC_FALSE;
404: break;
405: }
406: }
407: }
409: PetscCall(PetscStrlcat(buff, "\"", bufflen));
410: PetscCall(PetscStrlcat(buff, key, bufflen));
411: PetscCall(PetscStrlcat(buff, "\":", bufflen));
412: if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
413: PetscCall(PetscStrlcat(buff, value, bufflen));
414: if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
415: PetscFunctionReturn(PETSC_SUCCESS);
416: }