XRootD
XrdHttpUtils.hh File Reference

Utility functions for XrdHTTP. More...

#include "XProtocol/XPtypes.hh"
#include "XrdSec/XrdSecEntity.hh"
#include "XrdOuc/XrdOucIOVec.hh"
#include <string>
#include <vector>
+ Include dependency graph for XrdHttpUtils.hh:
+ This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Typedefs

typedef std::vector< XrdOucIOVec2XrdHttpIOList
 

Functions

void calcHashes (char *hash, const char *fn, kXR_int16 req, XrdSecEntity *secent, time_t tim, const char *key)
 
int compareHash (const char *h1, const char *h2)
 
char * escapeXML (const char *str)
 
bool Fromhexdigest (const unsigned char *input, int length, unsigned char *out)
 
std::string itos (long i)
 
char * mystrchrnul (const char *s, int c)
 
int parseURL (char *url, char *host, int &port, char **path)
 
char * quote (const char *str)
 
void Tobase64 (const unsigned char *input, int length, char *out)
 
char * unquote (char *str)
 

Detailed Description

Utility functions for XrdHTTP.

Author
Fabrizio Furano
Date
April 2013

Definition in file XrdHttpUtils.hh.

Typedef Documentation

◆ XrdHttpIOList

typedef std::vector<XrdOucIOVec2> XrdHttpIOList

Definition at line 95 of file XrdHttpUtils.hh.

Function Documentation

◆ calcHashes()

void calcHashes ( char *  hash,
const char *  fn,
kXR_int16  req,
XrdSecEntity secent,
time_t  tim,
const char *  key 
)

Definition at line 219 of file XrdHttpUtils.cc.

230  {
231 
232 
233 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
234  EVP_MAC *mac;
235  EVP_MAC_CTX *ctx;
236  size_t len;
237 #else
238  HMAC_CTX *ctx;
239  unsigned int len;
240 #endif
241  unsigned char mdbuf[EVP_MAX_MD_SIZE];
242  char buf[64];
243  struct tm tms;
244 
245 
246  if (!hash) {
247  return;
248  }
249  hash[0] = '\0';
250 
251  if (!key) {
252  return;
253  }
254 
255  if (!fn || !secent) {
256  return;
257  }
258 
259 #if OPENSSL_VERSION_NUMBER >= 0x30000000L
260 
261  mac = EVP_MAC_fetch(0, "sha256", 0);
262  ctx = EVP_MAC_CTX_new(mac);
263 
264  if (!ctx) {
265  return;
266  }
267 
268 
269  EVP_MAC_init(ctx, (const unsigned char *) key, strlen(key), 0);
270 
271 
272  if (fn)
273  EVP_MAC_update(ctx, (const unsigned char *) fn,
274  strlen(fn) + 1);
275 
276  EVP_MAC_update(ctx, (const unsigned char *) &request,
277  sizeof (request));
278 
279  if (secent->name)
280  EVP_MAC_update(ctx, (const unsigned char *) secent->name,
281  strlen(secent->name) + 1);
282 
283  if (secent->vorg)
284  EVP_MAC_update(ctx, (const unsigned char *) secent->vorg,
285  strlen(secent->vorg) + 1);
286 
287  if (secent->host)
288  EVP_MAC_update(ctx, (const unsigned char *) secent->host,
289  strlen(secent->host) + 1);
290 
291  if (secent->moninfo)
292  EVP_MAC_update(ctx, (const unsigned char *) secent->moninfo,
293  strlen(secent->moninfo) + 1);
294 
295  localtime_r(&tim, &tms);
296  strftime(buf, sizeof (buf), "%s", &tms);
297  EVP_MAC_update(ctx, (const unsigned char *) buf,
298  strlen(buf) + 1);
299 
300  EVP_MAC_final(ctx, mdbuf, &len, EVP_MAX_MD_SIZE);
301 
302  EVP_MAC_CTX_free(ctx);
303  EVP_MAC_free(mac);
304 
305 #else
306 
307  ctx = HMAC_CTX_new();
308 
309  if (!ctx) {
310  return;
311  }
312 
313 
314 
315  HMAC_Init_ex(ctx, (const void *) key, strlen(key), EVP_sha256(), 0);
316 
317 
318  if (fn)
319  HMAC_Update(ctx, (const unsigned char *) fn,
320  strlen(fn) + 1);
321 
322  HMAC_Update(ctx, (const unsigned char *) &request,
323  sizeof (request));
324 
325  if (secent->name)
326  HMAC_Update(ctx, (const unsigned char *) secent->name,
327  strlen(secent->name) + 1);
328 
329  if (secent->vorg)
330  HMAC_Update(ctx, (const unsigned char *) secent->vorg,
331  strlen(secent->vorg) + 1);
332 
333  if (secent->host)
334  HMAC_Update(ctx, (const unsigned char *) secent->host,
335  strlen(secent->host) + 1);
336 
337  if (secent->moninfo)
338  HMAC_Update(ctx, (const unsigned char *) secent->moninfo,
339  strlen(secent->moninfo) + 1);
340 
341  localtime_r(&tim, &tms);
342  strftime(buf, sizeof (buf), "%s", &tms);
343  HMAC_Update(ctx, (const unsigned char *) buf,
344  strlen(buf) + 1);
345 
346  HMAC_Final(ctx, mdbuf, &len);
347 
348  HMAC_CTX_free(ctx);
349 
350 #endif
351 
352  Tobase64(mdbuf, len / 2, hash);
353 }
void Tobase64(const unsigned char *input, int length, char *out)
static void HMAC_CTX_free(HMAC_CTX *ctx)
Definition: XrdHttpUtils.cc:65
static HMAC_CTX * HMAC_CTX_new()
Definition: XrdHttpUtils.cc:59
char * vorg
Entity's virtual organization(s)
Definition: XrdSecEntity.hh:71
char * name
Entity's name.
Definition: XrdSecEntity.hh:69
char * moninfo
Information for monitoring.
Definition: XrdSecEntity.hh:76
char * host
Entity's host name dnr dependent.
Definition: XrdSecEntity.hh:70

References HMAC_CTX_free(), HMAC_CTX_new(), XrdSecEntity::host, XrdSecEntity::moninfo, XrdSecEntity::name, Tobase64(), and XrdSecEntity::vorg.

Referenced by XrdHttpProtocol::Process(), and XrdHttpReq::Redir().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ compareHash()

int compareHash ( const char *  h1,
const char *  h2 
)

Definition at line 355 of file XrdHttpUtils.cc.

357  {
358 
359  if (h1 == h2) return 0;
360 
361  if (!h1 || !h2)
362  return 1;
363 
364  return strcmp(h1, h2);
365 
366 }

Referenced by XrdHttpProtocol::Process().

+ Here is the caller graph for this function:

◆ escapeXML()

char* escapeXML ( const char *  str)

Definition at line 455 of file XrdHttpUtils.cc.

455  {
456  int l = strlen(str);
457  char *r = (char *) malloc(l*6 + 1);
458  r[0] = '\0';
459  int i, j = 0;
460 
461  for (i = 0; i < l; i++) {
462  char c = str[i];
463 
464  switch (c) {
465  case '"':
466  strcpy(r + j, "&quot;");
467  j += 6;
468  break;
469  case '&':
470  strcpy(r + j, "&amp;");
471  j += 5;
472  break;
473  case '<':
474  strcpy(r + j, "&lt;");
475  j += 4;
476  break;
477  case '>':
478  strcpy(r + j, "&gt;");
479  j += 4;
480  break;
481  case '\'':
482  strcpy(r + j, "&apos;");
483  j += 6;
484  break;
485 
486  default:
487  r[j++] = c;
488  }
489  }
490 
491  r[j] = '\0';
492 
493  return r;
494 }

Referenced by XrdHttpReq::Error().

+ Here is the caller graph for this function:

◆ Fromhexdigest()

bool Fromhexdigest ( const unsigned char *  input,
int  length,
unsigned char *  out 
)

Definition at line 169 of file XrdHttpUtils.cc.

169  {
170  for (int idx=0; idx < length; idx += 2) {
171  int upper = char_to_int(input[idx]);
172  int lower = char_to_int(input[idx+1]);
173  if ((upper < 0) || (lower < 0)) {
174  return false;
175  }
176  out[idx/2] = (upper << 4) + lower;
177  }
178  return true;
179 }
static int char_to_int(int c)

References char_to_int().

+ Here is the call graph for this function:

◆ itos()

std::string itos ( long  i)

Definition at line 183 of file XrdHttpUtils.cc.

183  {
184  char buf[128];
185  sprintf(buf, "%ld", i);
186 
187  return buf;
188 }

◆ mystrchrnul()

char* mystrchrnul ( const char *  s,
int  c 
)

Definition at line 193 of file XrdHttpUtils.cc.

193  {
194  char *ptr = strchr((char *)s, c);
195 
196  if (!ptr)
197  return strchr((char *)s, '\0');
198 
199  return ptr;
200 }

◆ parseURL()

int parseURL ( char *  url,
char *  host,
int &  port,
char **  path 
)

Definition at line 77 of file XrdHttpUtils.cc.

77  {
78  // http://x.y.z.w:p/path
79 
80  *path = 0;
81 
82  // look for the second slash
83  char *p = strstr(url, "//");
84  if (!p) return -1;
85 
86 
87  p += 2;
88 
89  // look for the end of the host:port
90  char *p2 = strchr(p, '/');
91  if (!p2) return -1;
92 
93  *path = p2;
94 
95  char buf[256];
96  int l = std::min((int)(p2 - p), (int)sizeof (buf));
97  strncpy(buf, p, l);
98  buf[l] = '\0';
99 
100  // Now look for :
101  p = strchr(buf, ':');
102  if (p) {
103  int l = std::min((int)(p - buf), (int)sizeof (buf));
104  strncpy(host, buf, l);
105  host[l] = '\0';
106 
107  port = atoi(p + 1);
108  } else {
109  port = 0;
110 
111 
112  strcpy(host, buf);
113  }
114 
115  return 0;
116 }

Referenced by XrdHttpReq::ProcessHTTPReq().

+ Here is the caller graph for this function:

◆ quote()

char* quote ( const char *  str)

Definition at line 404 of file XrdHttpUtils.cc.

404  {
405  int l = strlen(str);
406  char *r = (char *) malloc(l*3 + 1);
407  r[0] = '\0';
408  int i, j = 0;
409 
410  for (i = 0; i < l; i++) {
411  char c = str[i];
412 
413  switch (c) {
414  case ' ':
415  strcpy(r + j, "%20");
416  j += 3;
417  break;
418  case '[':
419  strcpy(r + j, "%5B");
420  j += 3;
421  break;
422  case ']':
423  strcpy(r + j, "%5D");
424  j += 3;
425  break;
426  case ':':
427  strcpy(r + j, "%3A");
428  j += 3;
429  break;
430  case '/':
431  strcpy(r + j, "%2F");
432  j += 3;
433  break;
434  case '\n':
435  strcpy(r + j, "%0A");
436  j += 3;
437  break;
438  case '\r':
439  strcpy(r + j, "%0D");
440  j += 3;
441  break;
442  default:
443  r[j++] = c;
444  }
445  }
446 
447  r[j] = '\0';
448 
449  return r;
450 }

Referenced by XrdHttpReq::appendOpaque(), XrdHttpReq::ProcessHTTPReq(), and XrdHttpReq::Redir().

+ Here is the caller graph for this function:

◆ Tobase64()

void Tobase64 ( const unsigned char *  input,
int  length,
char *  out 
)

Definition at line 121 of file XrdHttpUtils.cc.

121  {
122  BIO *bmem, *b64;
123  BUF_MEM *bptr;
124 
125  if (!out) return;
126 
127  out[0] = '\0';
128 
129  b64 = BIO_new(BIO_f_base64());
130  BIO_set_flags(b64, BIO_FLAGS_BASE64_NO_NL);
131  bmem = BIO_new(BIO_s_mem());
132  BIO_push(b64, bmem);
133  BIO_write(b64, input, length);
134 
135  if (BIO_flush(b64) <= 0) {
136  BIO_free_all(b64);
137  return;
138  }
139 
140  BIO_get_mem_ptr(b64, &bptr);
141 
142 
143  memcpy(out, bptr->data, bptr->length);
144  out[bptr->length] = '\0';
145 
146  BIO_free_all(b64);
147 
148  return;
149 }
void BIO_set_flags(BIO *bio, int flags)

References BIO_set_flags().

Referenced by calcHashes().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ unquote()

char* unquote ( char *  str)

Definition at line 375 of file XrdHttpUtils.cc.

375  {
376  int l = strlen(str);
377  char *r = (char *) malloc(l + 1);
378  r[0] = '\0';
379  int i, j = 0;
380 
381  for (i = 0; i < l; i++) {
382 
383  if (str[i] == '%') {
384  char savec = str[i + 3];
385  str[i + 3] = '\0';
386 
387  r[j] = strtol(str + i + 1, 0, 16);
388  str[i + 3] = savec;
389 
390  i += 2;
391  } else r[j] = str[i];
392 
393  j++;
394  }
395 
396  r[j] = '\0';
397 
398  return r;
399 
400 }

Referenced by XrdHttpProtocol::Process().

+ Here is the caller graph for this function: