Actual source code: google.c


  2: #include <petscwebclient.h>
  3: #pragma clang diagnostic ignored "-Wdeprecated-declarations"
  4: #pragma gcc diagnostic   ignored "-Wdeprecated-declarations"

  6: /*
  7:    These variables identify the code as a PETSc application to Google.

  9:    See -   https://stackoverflow.com/questions/4616553/using-oauth-in-free-open-source-software
 10:    Users can get their own application IDs - https://code.google.com/p/google-apps-manager/wiki/GettingAnOAuthConsoleKey

 12: */
 13: #define PETSC_GOOGLE_CLIENT_ID "521429262559-i19i57eek8tnt9ftpp4p91rcl0bo9ag5.apps.googleusercontent.com"
 14: #define PETSC_GOOGLE_CLIENT_ST "vOds_A71I3_S_aHMq_kZAI0t"
 15: #define PETSC_GOOGLE_API_KEY   "AIzaSyDRZsOcySpWVzsUvIBL2UG3J2tcg-MXbyk"

 17: /*@C
 18:      PetscGoogleDriveRefresh - Get a new authorization token for accessing Google drive from PETSc from a refresh token

 20:    Not collective, only the first process in the `MPI_Comm` does anything

 22:    Input Parameters:
 23: +   comm - MPI communicator
 24: .   refresh token - obtained with `PetscGoogleDriveAuthorize()`, if NULL PETSc will first look for one in the options data
 25:                     if not found it will call `PetscGoogleDriveAuthorize()`
 26: -   tokensize - size of the output string access_token

 28:    Output Parameter:
 29: .   access_token - token that can be passed to `PetscGoogleDriveUpload()`

 31:    Options Database Key:
 32: .  -google_refresh_token XXX - where XXX was obtained from `PetscGoogleDriveAuthorize()`

 34:    Level: intermediate

 36: .seealso: `PetscURLShorten()`, `PetscGoogleDriveAuthorize()`, `PetscGoogleDriveUpload()`
 37: @*/
 38: PetscErrorCode PetscGoogleDriveRefresh(MPI_Comm comm, const char refresh_token[], char access_token[], size_t tokensize)
 39: {
 40:   SSL_CTX    *ctx;
 41:   SSL        *ssl;
 42:   int         sock;
 43:   char        buff[8 * 1024], body[1024];
 44:   PetscMPIInt rank;
 45:   char       *refreshtoken = (char *)refresh_token;
 46:   PetscBool   found;

 48:   MPI_Comm_rank(comm, &rank);
 49:   if (rank == 0) {
 50:     if (!refresh_token) {
 51:       PetscBool set;
 52:       PetscMalloc1(512, &refreshtoken);
 53:       PetscOptionsGetString(NULL, NULL, "-google_refresh_token", refreshtoken, sizeof(refreshtoken), &set);
 54:       if (!set) {
 55:         PetscGoogleDriveAuthorize(comm, access_token, refreshtoken, 512 * sizeof(char));
 56:         PetscFree(refreshtoken);
 57:         return 0;
 58:       }
 59:     }
 60:     PetscSSLInitializeContext(&ctx);
 61:     PetscHTTPSConnect("accounts.google.com", 443, ctx, &sock, &ssl);
 62:     PetscStrcpy(body, "client_id=");
 63:     PetscStrcat(body, PETSC_GOOGLE_CLIENT_ID);
 64:     PetscStrcat(body, "&client_secret=");
 65:     PetscStrcat(body, PETSC_GOOGLE_CLIENT_ST);
 66:     PetscStrcat(body, "&refresh_token=");
 67:     PetscStrcat(body, refreshtoken);
 68:     if (!refresh_token) PetscFree(refreshtoken);
 69:     PetscStrcat(body, "&grant_type=refresh_token");

 71:     PetscHTTPSRequest("POST", "accounts.google.com/o/oauth2/token", NULL, "application/x-www-form-urlencoded", body, ssl, buff, sizeof(buff));
 72:     PetscSSLDestroyContext(ctx);
 73:     close(sock);

 75:     PetscPullJSONValue(buff, "access_token", access_token, tokensize, &found);
 77:   }
 78:   return 0;
 79: }

 81: #include <sys/stat.h>

 83: /*@C
 84:      PetscGoogleDriveUpload - Loads a file to the Google Drive

 86:      Not collective, only the first process in the `MPI_Comm` uploads the file

 88:   Input Parameters:
 89: +   comm - MPI communicator
 90: .   access_token - obtained with PetscGoogleDriveRefresh(), pass NULL to have PETSc generate one
 91: -   filename - file to upload; if you upload multiple times it will have different names each time on Google Drive

 93:   Options Database Key:
 94: .  -google_refresh_token XXX - pass the access token for the operation

 96:   Usage Patterns:
 97: .vb
 98:     With PETSc option -google_refresh_token  XXX given
 99:     PetscGoogleDriveUpload(comm,NULL,filename);        will upload file with no user interaction

101:     Without PETSc option -google_refresh_token XXX given
102:     PetscGoogleDriveUpload(comm,NULL,filename);        for first use will prompt user to authorize access to Google Drive with their browser

104:     With PETSc option -google_refresh_token  XXX given
105:     PetscGoogleDriveRefresh(comm,NULL,access_token,sizeof(access_token));
106:     PetscGoogleDriveUpload(comm,access_token,filename);

108:     With refresh token entered in some way by the user
109:     PetscGoogleDriveRefresh(comm,refresh_token,access_token,sizeof(access_token));
110:     PetscGoogleDriveUpload(comm,access_token,filename);

112:     PetscGoogleDriveAuthorize(comm,access_token,refresh_token,sizeof(access_token));
113:     PetscGoogleDriveUpload(comm,access_token,filename);
114: .ve

116:    Level: intermediate

118: .seealso: `PetscURLShorten()`, `PetscGoogleDriveAuthorize()`, `PetscGoogleDriveRefresh()`
119: @*/
120: PetscErrorCode PetscGoogleDriveUpload(MPI_Comm comm, const char access_token[], const char filename[])
121: {
122:   SSL_CTX    *ctx;
123:   SSL        *ssl;
124:   int         sock;
125:   char        head[1024], buff[8 * 1024], *body, *title;
126:   PetscMPIInt rank;
127:   struct stat sb;
128:   size_t      len, blen, rd;
129:   FILE       *fd;
130:   int         err;

132:   MPI_Comm_rank(comm, &rank);
133:   if (rank == 0) {
134:     PetscStrcpy(head, "Authorization: Bearer ");
135:     PetscStrcat(head, access_token);
136:     PetscStrcat(head, "\r\n");
137:     PetscStrcat(head, "uploadType: multipart\r\n");

139:     err = stat(filename, &sb);
141:     len = 1024 + sb.st_size;
142:     PetscMalloc1(len, &body);
143:     PetscCall(PetscStrcpy(body, "--foo_bar_baz\r\n"
144:                                 "Content-Type: application/json\r\n\r\n"
145:                                 "{"));
146:     PetscPushJSONValue(body, "title", filename, len);
147:     PetscStrcat(body, ",");
148:     PetscPushJSONValue(body, "mimeType", "text.html", len);
149:     PetscStrcat(body, ",");
150:     PetscPushJSONValue(body, "description", "a file", len);
151:     PetscCall(PetscStrcat(body, "}\r\n\r\n"
152:                                 "--foo_bar_baz\r\n"
153:                                 "Content-Type: text/html\r\n\r\n"));
154:     PetscStrlen(body, &blen);
155:     fd = fopen(filename, "r");
157:     rd = fread(body + blen, sizeof(unsigned char), sb.st_size, fd);
159:     fclose(fd);
160:     body[blen + rd] = 0;
161:     PetscCall(PetscStrcat(body, "\r\n\r\n"
162:                                 "--foo_bar_baz\r\n"));
163:     PetscSSLInitializeContext(&ctx);
164:     PetscHTTPSConnect("www.googleapis.com", 443, ctx, &sock, &ssl);
165:     PetscHTTPSRequest("POST", "www.googleapis.com/upload/drive/v2/files/", head, "multipart/related; boundary=\"foo_bar_baz\"", body, ssl, buff, sizeof(buff));
166:     PetscFree(body);
167:     PetscSSLDestroyContext(ctx);
168:     close(sock);
169:     PetscStrstr(buff, "\"title\"", &title);
171:   }
172:   return 0;
173: }

175: #if defined(PETSC_HAVE_UNISTD_H)
176:   #include <unistd.h>
177: #endif

179: /*@C
180:      PetscGoogleDriveAuthorize - Get authorization and refresh token for accessing Google drive from PETSc

182:    Not collective, only the first process in `MPI_Comm` does anything

184:    Input Parameters:
185: +  comm - the MPI communicator
186: -  tokensize - size of the token arrays

188:    Output Parameters:
189: +  access_token - can be used with `PetscGoogleDriveUpload()` for this one session
190: -  refresh_token - can be used for ever to obtain new access_tokens with `PetscGoogleDriveRefresh()`, guard this like a password
191:                    it gives access to your Google Drive

193:    Notes:
194:     This call requires stdout and stdin access from process 0 on the MPI communicator

196:    You can run src/sys/webclient/tutorials/googleobtainrefreshtoken to get a refresh token and then in the future pass it to
197:    PETSc programs with -google_refresh_token XXX

199:    Level: intermediate

201: .seealso: `PetscGoogleDriveRefresh()`, `PetscGoogleDriveUpload()`, `PetscURLShorten()`
202: @*/
203: PetscErrorCode PetscGoogleDriveAuthorize(MPI_Comm comm, char access_token[], char refresh_token[], size_t tokensize)
204: {
205:   SSL_CTX    *ctx;
206:   SSL        *ssl;
207:   int         sock;
208:   char        buff[8 * 1024], *ptr, body[1024];
209:   PetscMPIInt rank;
210:   size_t      len;
211:   PetscBool   found;

213:   MPI_Comm_rank(comm, &rank);
214:   if (rank == 0) {
216:     PetscCall(PetscPrintf(comm, "Cut and paste the following into your browser:\n\n"
217:                                 "https://accounts.google.com/o/oauth2/auth?"
218:                                 "scope=https%%3A%%2F%%2Fwww.googleapis.com%%2Fauth%%2Fdrive.file&"
219:                                 "redirect_uri=urn:ietf:wg:oauth:2.0:oob&"
220:                                 "response_type=code&"
221:                                 "client_id=" PETSC_GOOGLE_CLIENT_ID "\n\n"));
222:     PetscPrintf(comm, "Paste the result here:");
223:     ptr = fgets(buff, 1024, stdin);
225:     PetscStrlen(buff, &len);
226:     buff[len - 1] = 0; /* remove carriage return at end of line */

228:     PetscSSLInitializeContext(&ctx);
229:     PetscHTTPSConnect("accounts.google.com", 443, ctx, &sock, &ssl);
230:     PetscStrcpy(body, "code=");
231:     PetscStrcat(body, buff);
232:     PetscStrcat(body, "&client_id=");
233:     PetscStrcat(body, PETSC_GOOGLE_CLIENT_ID);
234:     PetscStrcat(body, "&client_secret=");
235:     PetscStrcat(body, PETSC_GOOGLE_CLIENT_ST);
236:     PetscStrcat(body, "&redirect_uri=urn:ietf:wg:oauth:2.0:oob&");
237:     PetscStrcat(body, "grant_type=authorization_code");

239:     PetscHTTPSRequest("POST", "accounts.google.com/o/oauth2/token", NULL, "application/x-www-form-urlencoded", body, ssl, buff, sizeof(buff));
240:     PetscSSLDestroyContext(ctx);
241:     close(sock);

243:     PetscPullJSONValue(buff, "access_token", access_token, tokensize, &found);
245:     PetscPullJSONValue(buff, "refresh_token", refresh_token, tokensize, &found);

248:     PetscPrintf(comm, "Here is your Google refresh token, save it in a save place, in the future you can run PETSc\n");
249:     PetscPrintf(comm, "programs with the option -google_refresh_token %s\n", refresh_token);
250:     PetscPrintf(comm, "to access Google Drive automatically\n");
251:   }
252:   return 0;
253: }

255: /*@C
256:      PetscURLShorten - Uses Google's service to get a short url for a long url

258:     Input Parameters:
259: +    url - long URL you want shortened
260: -    lenshorturl - length of buffer to contain short URL

262:     Output Parameter:
263: .    shorturl - the shortened URL

265:    Level: intermediate

267:    Note:
268:    Google no longer provides this service so this routine will no longer function

270: .seealso: `PetscGoogleDriveRefresh()`, `PetscGoogleDriveUpload()`, `PetscGoogleDriveAuthorize()`
271: @*/
272: PetscErrorCode PetscURLShorten(const char url[], char shorturl[], size_t lenshorturl)
273: {
274:   SSL_CTX  *ctx;
275:   SSL      *ssl;
276:   int       sock;
277:   char      buff[1024], body[512], post[1024];
278:   PetscBool found;

280:   PetscSSLInitializeContext(&ctx);
281:   PetscHTTPSConnect("www.googleapis.com", 443, ctx, &sock, &ssl);
282:   PetscStrcpy(body, "{");
283:   PetscPushJSONValue(body, "longUrl", url, sizeof(body) - 2);
284:   PetscStrcat(body, "}");
285:   PetscSNPrintf(post, sizeof(post), "www.googleapis.com/urlshortener/v1/url?key=%s", PETSC_GOOGLE_API_KEY);
286:   PetscHTTPSRequest("POST", post, NULL, "application/json", body, ssl, buff, sizeof(buff));
287:   PetscSSLDestroyContext(ctx);
288:   close(sock);

290:   PetscPullJSONValue(buff, "id", shorturl, lenshorturl, &found);
292:   return 0;
293: }