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: $ saws/CA.pl -newcert (using the passphrase of password)
30: $ cat newkey.pem newcert.pem > sslclient.pem
32: and put the resulting file in either the current directory (with the application) or in the home directory. This seems kind of
33: silly but it was all I could figure out.
35: .seealso: `PetscSSLDestroyContext()`, `PetscHTTPSConnect()`, `PetscHTTPSRequest()`
36: @*/
37: PetscErrorCode PetscSSLInitializeContext(SSL_CTX **octx)
38: {
39: SSL_CTX *ctx;
40: #if defined(PETSC_USE_SSL_CERTIFICATE)
41: char keyfile[PETSC_MAX_PATH_LEN];
42: PetscBool exists;
43: #endif
45: PetscFunctionBegin;
46: if (!bio_err) {
47: SSL_library_init();
48: SSL_load_error_strings();
49: bio_err = BIO_new_fp(stderr, BIO_NOCLOSE);
50: }
52: /* Set up a SIGPIPE handler */
53: signal(SIGPIPE, sigpipe_handle);
55: /* suggested at https://mta.openssl.org/pipermail/openssl-dev/2015-May/001449.html */
56: #if (OPENSSL_VERSION_NUMBER >= 0x10100000L)
57: ctx = SSL_CTX_new(TLS_client_method());
58: #else
59: ctx = SSL_CTX_new(SSLv23_client_method());
60: #endif
61: SSL_CTX_set_mode(ctx, SSL_MODE_AUTO_RETRY);
63: #if defined(PETSC_USE_SSL_CERTIFICATE)
64: /* Locate keyfile */
65: PetscCall(PetscStrncpy(keyfile, "sslclient.pem", sizeof(keyfile)));
66: PetscCall(PetscTestFile(keyfile, 'r', &exists));
67: if (!exists) {
68: PetscCall(PetscGetHomeDirectory(keyfile, PETSC_MAX_PATH_LEN));
69: PetscCall(PetscStrlcat(keyfile, "/", sizeof(keyfile)));
70: PetscCall(PetscStrlcat(keyfile, "sslclient.pem", sizeof(keyfile)));
71: PetscCall(PetscTestFile(keyfile, 'r', &exists));
72: PetscCheck(exists, PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Unable to locate sslclient.pem file in current directory or home directory");
73: }
75: /* Load our keys and certificates*/
76: PetscCheck(SSL_CTX_use_certificate_chain_file(ctx, keyfile), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read certificate file");
78: SSL_CTX_set_default_passwd_cb(ctx, password_cb);
79: PetscCheck(SSL_CTX_use_PrivateKey_file(ctx, keyfile, SSL_FILETYPE_PEM), PETSC_COMM_SELF, PETSC_ERR_FILE_OPEN, "Cannot read key file");
80: #endif
82: *octx = ctx;
83: PetscFunctionReturn(PETSC_SUCCESS);
84: }
86: /*@C
87: PetscSSLDestroyContext - frees a `SSL_CTX` obtained with `PetscSSLInitializeContext()`
89: Input Parameter:
90: . ctx - the `SSL_CTX`
92: Level: advanced
94: .seealso: `PetscSSLInitializeContext()`, `PetscHTTPSConnect()`
95: @*/
96: PetscErrorCode PetscSSLDestroyContext(SSL_CTX *ctx)
97: {
98: PetscFunctionBegin;
99: SSL_CTX_free(ctx);
100: PetscFunctionReturn(PETSC_SUCCESS);
101: }
103: static PetscErrorCode PetscHTTPBuildRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], char **outrequest)
104: {
105: char *request = 0;
106: char contentlength[40], contenttype[80], *path, *host;
107: size_t request_len, headlen, bodylen, contentlen, pathlen, hostlen, typelen, contenttypelen = 0;
108: PetscBool flg;
110: PetscFunctionBegin;
111: PetscCall(PetscStrallocpy(url, &host));
112: PetscCall(PetscStrchr(host, '/', &path));
113: PetscCheck(path, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONGSTATE, "url must contain / it is %s", url);
114: *path = 0;
115: PetscCall(PetscStrlen(host, &hostlen));
117: PetscCall(PetscStrchr(url, '/', &path));
118: PetscCall(PetscStrlen(path, &pathlen));
120: if (header) {
121: PetscCall(PetscStrendswith(header, "\r\n", &flg));
122: PetscCheck(flg, PETSC_COMM_SELF, PETSC_ERR_ARG_WRONG, "header must end with \\r\\n");
123: }
125: PetscCall(PetscStrlen(type, &typelen));
126: if (ctype) {
127: PetscCall(PetscSNPrintf(contenttype, 80, "Content-Type: %s\r\n", ctype));
128: PetscCall(PetscStrlen(contenttype, &contenttypelen));
129: }
130: PetscCall(PetscStrlen(header, &headlen));
131: PetscCall(PetscStrlen(body, &bodylen));
132: PetscCall(PetscSNPrintf(contentlength, 40, "Content-Length: %d\r\n\r\n", (int)bodylen));
133: PetscCall(PetscStrlen(contentlength, &contentlen));
135: /* Now construct our HTTP request */
136: request_len = typelen + 1 + pathlen + hostlen + 100 + headlen + contenttypelen + contentlen + bodylen + 1;
137: PetscCall(PetscMalloc1(request_len, &request));
138: PetscCall(PetscStrncpy(request, type, request_len));
139: PetscCall(PetscStrlcat(request, " ", request_len));
140: PetscCall(PetscStrlcat(request, path, request_len));
141: PetscCall(PetscStrlcat(request, " HTTP/1.1\r\nHost: ", request_len));
142: PetscCall(PetscStrlcat(request, host, request_len));
143: PetscCall(PetscFree(host));
144: PetscCall(PetscStrlcat(request, "\r\nUser-Agent:PETScClient\r\n", request_len));
145: PetscCall(PetscStrlcat(request, header, request_len));
146: if (ctype) PetscCall(PetscStrlcat(request, contenttype, request_len));
147: PetscCall(PetscStrlcat(request, contentlength, request_len));
148: PetscCall(PetscStrlcat(request, body, request_len));
149: PetscCall(PetscStrlen(request, &request_len));
150: PetscCall(PetscInfo(NULL, "HTTPS request follows: \n%s\n", request));
152: *outrequest = request;
153: PetscFunctionReturn(PETSC_SUCCESS);
154: }
156: /*@C
157: PetscHTTPSRequest - Send a request to an HTTPS server
159: Input Parameters:
160: + type - either "POST" or "GET"
161: . url - URL of request host/path
162: . header - additional header information, may be NULL
163: . ctype - data type of body, for example application/json
164: . body - data to send to server
165: . ssl - obtained with `PetscHTTPSConnect()`
166: - buffsize - size of buffer
168: Output Parameter:
169: . buff - everything returned from server
171: Level: advanced
173: .seealso: `PetscHTTPRequest()`, `PetscHTTPSConnect()`, `PetscSSLInitializeContext()`, `PetscSSLDestroyContext()`, `PetscPullJSONValue()`
174: @*/
175: PetscErrorCode PetscHTTPSRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], SSL *ssl, char buff[], size_t buffsize)
176: {
177: char *request;
178: int r;
179: size_t request_len, len;
180: PetscBool foundbody = PETSC_FALSE;
182: PetscFunctionBegin;
183: PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
184: PetscCall(PetscStrlen(request, &request_len));
186: r = SSL_write(ssl, request, (int)request_len);
187: switch (SSL_get_error(ssl, r)) {
188: case SSL_ERROR_NONE:
189: PetscCheck(request_len == (size_t)r, PETSC_COMM_SELF, PETSC_ERR_LIB, "Incomplete write to SSL socket");
190: break;
191: default:
192: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL socket write problem");
193: }
195: /* Now read the server's response, globus sends it in two chunks hence must read a second time if needed */
196: PetscCall(PetscArrayzero(buff, buffsize));
197: len = 0;
198: foundbody = PETSC_FALSE;
199: do {
200: char *clen;
201: int cl;
202: size_t nlen;
204: r = SSL_read(ssl, buff + len, (int)buffsize);
205: len += r;
206: switch (SSL_get_error(ssl, r)) {
207: case SSL_ERROR_NONE:
208: break;
209: case SSL_ERROR_ZERO_RETURN:
210: foundbody = PETSC_TRUE;
211: SSL_shutdown(ssl);
212: break;
213: case SSL_ERROR_SYSCALL:
214: foundbody = PETSC_TRUE;
215: break;
216: default:
217: SETERRQ(PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL read problem");
218: }
220: PetscCall(PetscStrstr(buff, "Content-Length: ", &clen));
221: if (clen) {
222: clen += 15;
223: sscanf(clen, "%d", &cl);
224: if (!cl) foundbody = PETSC_TRUE;
225: else {
226: PetscCall(PetscStrstr(buff, "\r\n\r\n", &clen));
227: if (clen) {
228: PetscCall(PetscStrlen(clen, &nlen));
229: if (nlen - 4 == (size_t)cl) foundbody = PETSC_TRUE;
230: }
231: }
232: } else {
233: /* if no content length than must leave because you don't know if you can read again */
234: foundbody = PETSC_TRUE;
235: }
236: } while (!foundbody);
237: PetscCall(PetscInfo(NULL, "HTTPS result follows: \n%s\n", buff));
239: SSL_free(ssl);
240: PetscCall(PetscFree(request));
241: PetscFunctionReturn(PETSC_SUCCESS);
242: }
244: /*@C
245: PetscHTTPRequest - Send a request to an HTTP server
247: Input Parameters:
248: + type - either "POST" or "GET"
249: . url - URL of request host/path
250: . header - additional header information, may be NULL
251: . ctype - data type of body, for example application/json
252: . body - data to send to server
253: . sock - obtained with `PetscOpenSocket()`
254: - buffsize - size of buffer
256: Output Parameter:
257: . buff - everything returned from server
259: Level: advanced
261: .seealso: `PetscHTTPSRequest()`, `PetscOpenSocket()`, `PetscHTTPSConnect()`, `PetscPullJSONValue()`
262: @*/
263: PetscErrorCode PetscHTTPRequest(const char type[], const char url[], const char header[], const char ctype[], const char body[], int sock, char buff[], size_t buffsize)
264: {
265: char *request;
266: size_t request_len;
268: PetscFunctionBegin;
269: PetscCall(PetscHTTPBuildRequest(type, url, header, ctype, body, &request));
270: PetscCall(PetscStrlen(request, &request_len));
272: PetscCall(PetscBinaryWrite(sock, request, request_len, PETSC_CHAR));
273: PetscCall(PetscFree(request));
274: PetscCall(PetscBinaryRead(sock, buff, buffsize, NULL, PETSC_CHAR));
275: buff[buffsize - 1] = 0;
276: PetscCall(PetscInfo(NULL, "HTTP result follows: \n%s\n", buff));
277: PetscFunctionReturn(PETSC_SUCCESS);
278: }
280: /*@C
281: PetscHTTPSConnect - connect to a HTTPS server
283: Input Parameters:
284: + host - the name of the machine hosting the HTTPS server
285: . port - the port number where the server is hosting, usually 443
286: - ctx - value obtained with `PetscSSLInitializeContext()`
288: Output Parameters:
289: + sock - socket to connect
290: - ssl - the argument passed to `PetscHTTPSRequest()`
292: Level: advanced
294: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`
295: @*/
296: PetscErrorCode PetscHTTPSConnect(const char host[], int port, SSL_CTX *ctx, int *sock, SSL **ssl)
297: {
298: BIO *sbio;
300: PetscFunctionBegin;
301: /* Connect the TCP socket*/
302: PetscCall(PetscOpenSocket(host, port, sock));
304: /* Connect the SSL socket */
305: *ssl = SSL_new(ctx);
306: sbio = BIO_new_socket(*sock, BIO_NOCLOSE);
307: SSL_set_bio(*ssl, sbio, sbio);
308: PetscCheck(SSL_connect(*ssl) > 0, PETSC_COMM_SELF, PETSC_ERR_LIB, "SSL connect error");
309: PetscFunctionReturn(PETSC_SUCCESS);
310: }
312: /*@C
313: PetscPullJSONValue - Given a JSON response containing the substring with "key" : "value" where there may or not be spaces around the : returns the value.
315: Input Parameters:
316: + buff - the char array containing the possible values
317: . key - the key of the requested value
318: - valuelen - the length of the array to contain the value associated with the key
320: Output Parameters:
321: + value - the value obtained
322: - found - flag indicating if the value was found in the buff
324: Level: advanced
326: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPushJSONValue()`
327: @*/
328: PetscErrorCode PetscPullJSONValue(const char buff[], const char key[], char value[], size_t valuelen, PetscBool *found)
329: {
330: char *v, *w;
331: char work[256];
332: size_t len;
334: PetscFunctionBegin;
335: PetscCall(PetscStrncpy(work, "\"", sizeof(work)));
336: PetscCall(PetscStrlcat(work, key, sizeof(work)));
337: PetscCall(PetscStrlcat(work, "\":", sizeof(work)));
338: PetscCall(PetscStrstr(buff, work, &v));
339: PetscCall(PetscStrlen(work, &len));
340: if (v) {
341: v += len;
342: } else {
343: work[len++ - 1] = 0;
344: PetscCall(PetscStrlcat(work, " :", sizeof(work)));
345: PetscCall(PetscStrstr(buff, work, &v));
346: if (!v) {
347: *found = PETSC_FALSE;
348: PetscFunctionReturn(PETSC_SUCCESS);
349: }
350: v += len;
351: }
352: PetscCall(PetscStrchr(v, '\"', &v));
353: if (!v) {
354: *found = PETSC_FALSE;
355: PetscFunctionReturn(PETSC_SUCCESS);
356: }
357: PetscCall(PetscStrchr(v + 1, '\"', &w));
358: if (!w) {
359: *found = PETSC_FALSE;
360: PetscFunctionReturn(PETSC_SUCCESS);
361: }
362: *found = PETSC_TRUE;
363: PetscCall(PetscStrncpy(value, v + 1, PetscMin((size_t)(w - v), valuelen)));
364: PetscFunctionReturn(PETSC_SUCCESS);
365: }
367: #include <ctype.h>
369: /*@C
370: PetscPushJSONValue - Puts a "key" : "value" pair onto a string
372: Input Parameters:
373: + buffer - the char array where the value will be put
374: . key - the key value to be set
375: . value - the value associated with the key
376: - bufflen - the size of the buffer (currently ignored)
378: Level: advanced
380: Note:
381: Ignores lengths so can cause buffer overflow
383: .seealso: `PetscOpenSocket()`, `PetscHTTPSRequest()`, `PetscSSLInitializeContext()`, `PetscPullJSONValue()`
384: @*/
385: PetscErrorCode PetscPushJSONValue(char buff[], const char key[], const char value[], size_t bufflen)
386: {
387: size_t len;
388: PetscBool special;
390: PetscFunctionBegin;
391: PetscCall(PetscStrcmp(value, "null", &special));
392: if (!special) PetscCall(PetscStrcmp(value, "true", &special));
393: if (!special) PetscCall(PetscStrcmp(value, "false", &special));
394: if (!special) {
395: PetscInt i;
397: PetscCall(PetscStrlen(value, &len));
398: special = PETSC_TRUE;
399: for (i = 0; i < (int)len; i++) {
400: if (!isdigit(value[i])) {
401: special = PETSC_FALSE;
402: break;
403: }
404: }
405: }
407: PetscCall(PetscStrlcat(buff, "\"", bufflen));
408: PetscCall(PetscStrlcat(buff, key, bufflen));
409: PetscCall(PetscStrlcat(buff, "\":", bufflen));
410: if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
411: PetscCall(PetscStrlcat(buff, value, bufflen));
412: if (!special) PetscCall(PetscStrlcat(buff, "\"", bufflen));
413: PetscFunctionReturn(PETSC_SUCCESS);
414: }