FARGOS/VISTA Object Management Environment Core  ..
FARGOS/VISTA Object Management Environment Core Table of Contents
HTTPembeddedServer.hpp
Go to the documentation of this file.
1 #ifndef _HTTP_EMBEDDED_SERVER_HPP_
2 #define _HTTP_EMBEDDED_SERVER_HPP_ "$Id: HTTPembeddedServer.hpp 411 2020-07-13 03:02:58Z geoff $"
4 
6 #include <map>
7 #include <set>
8 
10 #include <utils/io/read_file.hpp>
11 
26 public:
28  unsigned char bytes[63];
29  struct sockaddr genericAddr;
30  struct sockaddr_in ipv4;
31  struct sockaddr_in6 ipv6;
32 #ifndef _WIN32
33  struct sockaddr_un filename;
34 #endif
35  } socketAddress;
36  uint8_t addressLength;
37 
54  int setFromHostAndPort(const char *targetAddress, uint16_t port) {
55  const char *address = targetAddress;
56  int l = (int) strlen(address);
57  const char *colon = (const char *) memchr(address, ':', l);
58 
59  int selectedFamily = AF_INET;
60 
61  if (colon != nullptr) {
62  uint_fast32_t prefixLen = (uint_fast32_t) (colon - address);
63  if (prefixLen == 4) {
64  if (memcmp(address, "ipv4:", 5) == 0) { // IP V4
65  selectedFamily = AF_INET;
66  address += 5;
67  if ((*address == '/') && (*(address + 1) == '/')) {
68  address += 2; // skip leading "/"
69  }
70  } else if (memcmp(address, "ipv6:", 5) == 0) { // IP V6
71  selectedFamily = AF_INET6;
72  address += 5;
73  if ((*address == '/') && (*(address + 1) == '/')) {
74  address += 2; // skip leading "/"
75  }
76 #ifndef _WIN32
77  } else if (memcmp(address, "file:", 5) == 0) { // file domain
78  selectedFamily = AF_LOCAL; // AF_UNIX
79  address += 5;
80  if ((*address == '/') && (*(address + 1) == '/')) {
81  address += 2; // skip leading "/"
82  }
83  socketAddress.filename.sun_family = AF_LOCAL;
84  strncpy(socketAddress.filename.sun_path, address, sizeof(socketAddress.filename.sun_path));
85  addressLength = strlen(socketAddress.filename.sun_path);
86  return (addressLength);
87 #endif
88  }
89  }
90  }
91  int rc;
92  switch (selectedFamily) {
93  case AF_INET:
94  memset(&socketAddress.ipv4, 0, sizeof(socketAddress.ipv4));
95  socketAddress.ipv4.sin_family = AF_INET;
96  rc = inet_pton(selectedFamily, address, &socketAddress.ipv4.sin_addr);
97  socketAddress.ipv4.sin_port = htons(port);
98  addressLength = sizeof(struct sockaddr_in);
99  break;
100  case AF_INET6:
101  memset(&socketAddress.ipv6, 0, sizeof(socketAddress.ipv6));
102  socketAddress.ipv6.sin6_family = AF_INET6;
103  rc = inet_pton(selectedFamily, address, &socketAddress.ipv6.sin6_addr);
104  socketAddress.ipv6.sin6_port = htons(port);
105  addressLength = sizeof(struct sockaddr_in6);
106  break;
107  default:
108  rc = -1;
109  addressLength = 0;
110  break;
111  } // end switch selected address family
112  return (addressLength);
113  }
114 
121  int setFromURL(const char *addressString)
122  {
123  enum { MAX_COLONS = 16 };
124  char workBfr[2048];
125  char *colonAddr[MAX_COLONS];
126 
127  uint_fast8_t colonsSeen = 0;
128 
129  const char *src = addressString;
130  char *dest = workBfr;
131 
132  while (*src != '\0') {
133  if (*src == ':') {
134  if (colonsSeen < MAX_COLONS) {
135  colonAddr[colonsSeen] = dest;
136  colonsSeen += 1;
137  }
138  }
139  *(dest++) = *(src++);
140  }
141  int port = 0;
142  if (colonsSeen != 0) { // port specified
143  uint32_t offsetOfLastColon = (uint32_t) (colonAddr[colonsSeen - 1] - workBfr);
144  if (offsetOfLastColon > 5) { // not ipv4: or similar prefix
145  *colonAddr[colonsSeen - 1] = '\0'; // terminate host portion
146  uint32_t portLen = (uint32_t) (dest - colonAddr[colonsSeen - 1]);
147  if (portLen < 7) { // :65535 + null
148  port = text2uint32(colonAddr[colonsSeen - 1] + 1, portLen - 1);
149  }
150  }
151  }
152  int result = setFromHostAndPort(workBfr, port);
153  return (result);
154  }
155 
157  addressLength = 0;
158  }
159 
160  explicit GenericSocketAddress(const struct sockaddr_in ipv4) OME_ALWAYS_INLINE {
161  socketAddress.ipv4 = ipv4;
162  addressLength = sizeof(struct sockaddr_in);
163  }
164 
165  explicit GenericSocketAddress(const struct sockaddr_in6 ipv6) OME_ALWAYS_INLINE {
166  socketAddress.ipv6 = ipv6;
167  addressLength = sizeof(struct sockaddr_in6);
168  }
169 
170  explicit GenericSocketAddress(const char *addressString) {
171  setFromURL(addressString);
172  }
173 
174  explicit GenericSocketAddress(const struct sockaddr *generic_addr, socklen_t addrLen) OME_ALWAYS_INLINE {
175  // we can only hold so much...so don't try to copy more
176  if (addrLen > sizeof(socketAddress)) {
177  addressLength = sizeof(socketAddress);
178  } else {
179  addressLength = (uint8_t) addrLen;
180  }
181  memcpy(&socketAddress.genericAddr, generic_addr, addressLength);
182  }
183 
184  GenericSocketAddress(const char *address, uint16_t port) {
185  setFromHostAndPort(address, port);
186  }
187 
188  GenericSocketAddress(const std::string &address, uint16_t port) {
189  setFromHostAndPort(address.c_str(), port);
190  }
191 
192  GenericSocketAddress &operator=(const struct sockaddr_in ipv4) OME_ALWAYS_INLINE {
193  socketAddress.ipv4 = ipv4;
194  addressLength = sizeof(struct sockaddr_in);
195  return (*this);
196  }
197 
198  GenericSocketAddress &operator=(const struct sockaddr_in6 ipv6) OME_ALWAYS_INLINE {
199  socketAddress.ipv6 = ipv6;
200  addressLength = sizeof(struct sockaddr_in6);
201  return (*this);
202  }
203 
215  int copyAddressAndPort(char *addrText, uint32_t bfrSize, bool includeURLprefix=false) const {
216  int port;
217 
218  if (bfrSize < 8) { // answer won't fit
219  addrText[0] = '\0';
220  return (-1);
221  }
222 
223  /* Windows has flawed declarations which do not include
224  * the const attribute for the incoming address
225  */
226  uint_fast8_t offset = 0;
227  int32_t bfrLeft = (int32_t) bfrSize;
228  switch (socketAddress.genericAddr.sa_family) {
229  case AF_INET:
230  if (includeURLprefix == true) {
231  memcpy(addrText, "ipv4://", 7);
232  offset += 7;
233  bfrLeft -= 7;
234  if (bfrLeft < 0) {
235  bfrLeft = 0;
236  }
237  }
238  inet_ntop(AF_INET, const_cast<struct in_addr *>(&socketAddress.ipv4.sin_addr), addrText + offset, bfrLeft);
239  port = ntohs(socketAddress.ipv4.sin_port);
240  break;
241  case AF_INET6:
242  if (includeURLprefix == true) {
243  memcpy(addrText, "ipv6://", 7);
244  offset += 7;
245  bfrLeft -= 7;
246  if (bfrLeft < 0) {
247  bfrLeft = 0;
248  }
249  }
250  inet_ntop(AF_INET6, const_cast<struct in6_addr *>(&socketAddress.ipv6.sin6_addr), addrText + offset, bfrLeft);
251  port = ntohs(socketAddress.ipv6.sin6_port);
252  break;
253 #ifndef _WIN32
254  case AF_LOCAL:
255  if (includeURLprefix == true) {
256  memcpy(addrText, "file://", 7);
257  offset += 7;
258  bfrLeft -= 7;
259  if (bfrLeft < 0) {
260  bfrLeft = 0;
261  }
262  }
263  safe_strcpy(addrText + offset, socketAddress.filename.sun_path, bfrLeft);
264  return (0); // there is no port with this address type
265 #endif
266  default:
267 #ifndef _WIN32
268  snprintf
269 #else
270  _snprintf
271 #endif
272  (addrText, bfrSize, "unrecognizedAF%u", socketAddress.genericAddr.sa_family);
273  port = 0;
274  break;
275  }
276  return (port);
277  }
278 
291  char *getAddressAndPort(char *bfr, uint32_t bfrSize, bool includeURLprefix=false) const {
292  char addrText[64];
293  int port = copyAddressAndPort(addrText, sizeof(addrText), includeURLprefix);
294 
295 #ifndef _WIN32
296  snprintf(bfr, bfrSize, "%s:%d", addrText, port);
297 #else
298  _snprintf(bfr, bfrSize, "%s:%d", addrText, port);
299 #endif
300  return (bfr);
301  }
302 
304  if (OME_EXPECT_FALSE(addressLength != arg.addressLength)) {
305  return (false);
306  }
307  int rc = memcmp(&socketAddress, &arg.socketAddress, addressLength);
308  return (rc == 0);
309  }
310 
312  if (OME_EXPECT_FALSE(addressLength != arg.addressLength)) {
313  return (true);
314  }
315  int rc = memcmp(&socketAddress, &arg.socketAddress, addressLength);
316  return (rc != 0);
317  }
318 
320  int rc;
321  // rarely will we compare addresses from different families
322  if (OME_EXPECT_FALSE(addressLength < arg.addressLength)) {
323  rc = memcmp(&socketAddress, &arg.socketAddress, addressLength);
324  if (rc <= 0) { // earlier, or matches everything but was shorter
325  return (true);
326  }
327  return (false);
328  }
329  // argument (right hand side) length is same or shorter
330  rc = memcmp(&socketAddress, &arg.socketAddress, arg.addressLength);
331  if (rc < 0) {
332  return (true);
333  }
334  return (false);
335  }
336 
338  int rc;
339  // normally we will compare addresses from the same family
340  if (OME_EXPECT_TRUE(addressLength <= arg.addressLength)) {
341  rc = memcmp(&socketAddress, &arg.socketAddress, addressLength);
342  if (rc <= 0) { // earlier, or matches to our possibly shorter length
343  return (false);
344  }
345  return (true);
346  }
347  // argument (right hand side) is shorter
348  rc = memcmp(&socketAddress, &arg.socketAddress, arg.addressLength);
349  if (rc < 0) { // earlier
350  return (false);
351  }
352  // above or matches to their shorter length
353  return (true);
354  }
355 
356 }; // end class GenericSocketAddress
357 
358 template <typename STREAMTYPE> inline STREAMTYPE & operator<<(STREAMTYPE &os, const GenericSocketAddress &arg)
359 {
360  os << "[GenericSocketAddress={";
361  os << " address=\"" << arg.socketAddress.genericAddr << "\"";
362 // os << " addressLength=" << arg.addressLength;
363  os << " }]";
364  return (os);
365 }
366 
367 
368 #pragma GCC diagnostic push
369 #pragma GCC diagnostic ignored "-Wsuggest-final-types"
370 
379 {
380 public:
381  struct ltCharPtrStr {
382  bool operator()(const char *arg1, const char *arg2) const {
383  int rc = strcmp(arg1, arg2);
384  if (rc < 0) return (true);
385  return (false);
386  }
387  }; // end struct ltCharPtrStr
388 
391  typedef ssize_t (*HTTPcallbackFP)(HTTP_SessionRecord *session,
392  const char *cmd, char *url,
393  unsigned char *block, size_t blockLen);
394 
395  typedef std::map<const char *, const char *, ltCharPtrStr> OptionsAttrValMap_t;
396 
399  void *userData;
402 protected:
403  std::map<std::string,HTTPcallbackFP> httpRequestHandlerTable;
404 
405 protected:
413  virtual ssize_t handleHTTPrequest(unsigned char *block, size_t blockLen);
414 
417  void closeConnection();
418 
419  // NOTE: not static due to keep-alive state
420  int_fast32_t prepareResponseHeader(void *outputBfr, size_t bfrLen,
421  uint_fast32_t statusCodeValue=200, const char *statusText="OK",
422  const char *extraHeaders="",
423  ssize_t contentLength=0, const char *extraContent="");
424 
425  ssize_t sendResponse(const void *bfr, size_t bfrLen);
426  // TODO: provide iovec equivalent
427 
428 public:
443  const GenericSocketAddress *from, void *extraData = nullptr,
444  size_t maxDocSize=1024*128) :
446  fromAddress(*from)
447  {
448  controller = io;
449  bfrMgr = mgr;
450  userData = extraData;
452  }
453 
454 #pragma GCC diagnostic push
455 #pragma GCC diagnostic ignored "-Wsuggest-final-methods"
457  // controller is eventually deleted by HTTPembeddedServerBase::startHTTPacceptThread()
458  delete bfrMgr;
459  }
460 #pragma GCC diagnostic pop
461 
462  /* \brief Convert %XX hex escape into the appropriate character,
463  * possibly shrinking the result string in place.
464  *
465  * \param bfr holds the string to be converted. It may be modified in
466  * place, if necessary.
467  *
468  * \return The end of the converted string is returned.
469  */
470  static char *convertHTTPescapes(char *bfr, int_fast32_t bfrLen=-1,
471  bool nullTerminate=false);
472 
492  static int_fast32_t parseOptions(OptionsAttrValMap_t *tbl, char *optionText,
493  int_fast32_t optionLength=-1);
494 
500  void addHTTPhandler(const char *cmd, HTTPcallbackFP routine) {
501  httpRequestHandlerTable[cmd] = routine;
502  }
503 
512  void setCloseAfterRequestFlag(bool doClose) {
513  closeWhenRequestComplete = doClose;
514  }
515 
520 #pragma GCC diagnostic push
521 #pragma GCC diagnostic ignored "-Wsuggest-final-methods"
522  virtual void connectionEOF() {
523  LOG_COMPONENT_CERR(app,info) << "EOF from client " << fromAddress.socketAddress.genericAddr << LOG_ENDLINE;
524  closeConnection();
525  }
526 #pragma GCC diagnostic pop
527 
535  virtual int_fast32_t processBlock(unsigned char *blockStart, size_t blockLen) VIRTUAL_OVERRIDE {
536  LOG_COMPONENT_CERR(app,info) << "from=" << fromAddress.socketAddress.genericAddr << " processBlock, len=" << blockLen << " content=" << AS_TEXT_BUFFER((const char *) blockStart, blockLen) << LOG_ENDLINE;
537  int_fast32_t rc = handleHTTPrequest(blockStart, blockLen);
538  return (rc);
539  }
540 
547  virtual int processHTTPheader(unsigned char *line, size_t lineLen) VIRTUAL_OVERRIDE {
548  if (line[lineLen - 1] == '\n') {
549  lineLen -= 1;
550  if (line[lineLen - 1] == '\r') {
551  lineLen -= 1;
552  }
553  }
554  if (lineLen == 0) { // end of HTTP headers
555  if (contentLengthWanted <= 0) {
556  // TODO:
557  LOG_COMPONENT_CERR(app,info) << "Saw end of HTTP headers from=\"" << fromAddress.socketAddress.genericAddr << "\" Process incoming request" << LOG_ENDLINE;
558  int rc = handleHTTPrequest(nullptr, 0);
559  return (rc);
560  }
561  LOG_COMPONENT_CERR(app,info) << "Saw end of HTTP headers from=\"" << fromAddress.socketAddress.genericAddr << "\" Content-Length: " << contentLengthWanted << LOG_ENDLINE;
562  // remaining block of data will be read and passed to processBlock()
563  return (0);
564  }
565  int rc = Parse_And_Process_HTTP_Stream::processHTTPheader(line, lineLen);
566  return (rc);
567  }
568 
569 #pragma GCC diagnostic push
570 #pragma GCC diagnostic ignored "-Wsuggest-final-methods"
571 
574  virtual bool interestedInEvent(const class HTTPeventStateRecord *record) {
575  return (true);
576  }
577 #pragma GCC diagnostic push
578 
582  static int default_OPTIONS(HTTP_SessionRecord *session, const char *cmd,
583  char *url, unsigned char *block, size_t blockLen);
584 
585 }; // end class HTTP_SessionRecord
586 
587 #pragma GCC diagnostic pop
588 
589 template <typename STREAMTYPE> inline STREAMTYPE & operator<<(STREAMTYPE &os, const HTTP_SessionRecord &arg)
590 {
591  os << "[HTTP_SessionRecord={";
592  os << " fromAddr=" << arg.fromAddress;
593  os << " closeWhenComplete=" << arg.closeWhenRequestComplete;
594  os << " }]";
595  return (os);
596 }
597 
607 protected:
608  char serverName[64];
609 #ifdef _WIN32
610  HANDLE acceptThreadID;
611 #else
612  pthread_t acceptThreadID;
613 #endif
614 
615 public:
616  void *userData;
618  uint32_t bufferSize;
620  uint16_t listenPort;
623 
624 protected:
625  static int readHTTPstream(SharedBufferAllocRecord *rec, IO_Processor *controller);
626 #ifdef WIN32
627  static DWORD WINAPI startHTTPacceptThread(void *arg);
628 #else
629  static void *startHTTPacceptThread(void *arg);
630 #endif
631 
632 public:
650  HTTPembeddedServerBase(uint16_t port, void *extraData=nullptr,
651  const char *useServerName=nullptr, uint32_t useBfrSize=0,
652  uint16_t maxEventLength=0)
653  {
654  listenPort = port;
655  userData = extraData;
656  bufferSize = useBfrSize;
657  maxHTTPeventLength = maxEventLength;
658  stopAccepting = false;
659  listenActive = false;
660  if (useServerName == nullptr) { // none specified
661 #ifndef _WIN32
662  gethostname(serverName, sizeof(serverName));
663 #else
664  DWORD nameLen = sizeof(serverName);
665  GetComputerName(serverName, &nameLen);
666 #endif
667 
668  char *cp = serverName;
669  while (*cp != '\0') {
670  if (*cp == '.') { // terminate on first "."
671  *cp = '\0';
672  break;
673  }
674  if (isupper(*cp)) {
675  *cp = tolower(*cp);
676  }
677  cp += 1;
678  }
679  } else {
680  safe_strcpy(serverName, useServerName, sizeof(serverName));
681  }
682  }
683 
685 
688  void setBufferSize(uint32_t bfrSize) {
689  bufferSize = bfrSize;
690  }
691 
694  void setHTTPeventLength(uint32_t maxLen) {
695  maxHTTPeventLength = maxLen;
696  }
697 
700  const char *getServerName() const {
701  return (serverName);
702  }
703 
710  int startHTTPlisten();
711 
714  int stopHTTPlisten(const char *reason);
715 
718  int waitForHTTPstop();
719 
726  virtual HTTP_SessionRecord *acceptNewConnection(IO_Processor *io, CircularBufferManager *mgr, const GenericSocketAddress *from, void *extraData) = 0;
727 
728 }; // end class HTTPembeddedServerBase
729 
737 template <typename ACCEPT_CLASS=HTTP_SessionRecord, typename USER_CLASS=void> class HTTPembeddedServer : public HTTPembeddedServerBase
738 {
739 public:
740  HTTPembeddedServer(uint16_t port, USER_CLASS *extraData=0,
741  const char *useServerName=0, uint32_t useBfrSize=0,
742  uint16_t maxEventLen=0) :
743  HTTPembeddedServerBase(port, extraData, useServerName, useBfrSize, maxEventLen) {
744  }
745 
746  virtual ~HTTPembeddedServer() {}
747 
749  ACCEPT_CLASS *sessionRec = new ACCEPT_CLASS(io, mgr, from,
750  reinterpret_cast<USER_CLASS *>(extraData));
751  // NOTE: ACCEPT_CLASS pointer will be demoted to base class pointer
752  return (sessionRec);
753  }
754 
757  USER_CLASS *getUserData() const {
758  return (reinterpret_cast<USER_CLASS *>(userData));
759  }
760 }; // end class HTTPembeddedServer<>
761 
762 
763 /* NOTE: the remaining classes support sending streams of events via
764  * HTTP to a client making use of an XMLHttpRequest() object.
765  */
766 
771 {
772 public:
773  enum { MAX_STATUS_LINE_LENGTH = 448 };
774  const void *extraData;
775  uint64_t updateTime;
776  uint32_t lineLength;
777  uint32_t eventRecordId;
778  char eventType[24];
780 
781  explicit HTTPeventStateRecord(uint32_t id=0) {
782  extraData = nullptr;
783  updateTime = 0;
784  lineLength = 0;
785  eventRecordId = id;
786  }
787 }; // end class HTTPeventStateRecord
788 
789 template <typename STREAMTYPE> inline STREAMTYPE & operator<<(STREAMTYPE &os, const HTTPeventStateRecord &arg)
790 {
791  os << "[HTTPeventStateRecord={";
792  os << " updateTime=" << arg.updateTime;
793  os << " eventType=\"" << arg.eventType << "\"";
794  os << " eventId=" << arg.eventRecordId;
795  os << " line=\"" << AS_ESCAPED_TEXT_BUFFER(arg.lineData, arg.lineLength) << "\"";
796  os << " }]";
797  return (os);
798 }
799 
803  const void *object;
804  char eventType[32];
805 };
806 
810 {
811  bool operator()(const HTTPstatusRecordKey &arg1, const HTTPstatusRecordKey &arg2) const {
812  if (arg1.object < arg2.object) return (true);
813  if (arg1.object > arg2.object) return (false);
814  // must be same
815  int rc = strcmp(arg1.eventType, arg2.eventType);
816  if (rc < 0) return (true);
817  return (false);
818  }
819 }; // end struct ltHTTPstatusRecordKey
820 
829 {
830 public:
832 
834 
840  virtual void receiveNotice(const unsigned char *bfr, uint32_t bfrLen,
841  const char *eventType="log") = 0;
842 }; // end class HTTPnotificationReceiverInterface
843 
852 {
853 protected:
854  std::set<HTTPnotificationReceiverInterface *> interestedClients;
855 public:
856  static int forwardToClients(SharedBufferAllocRecord *rec, IO_Processor *controller);
858 
859  explicit HTTPnotificationPublisher(const char *name) :
860 #ifndef _WIN32
861  LogManager(0, -1, 0, name,
862  LogMessageRecord::LOG_TIMESTAMP | LogMessageRecord::LOG_ERROR_LEVEL),
863 #else
864  LogManager(0, INVALID_HANDLE_VALUE, 0, name,
865  LogMessageRecord::LOG_TIMESTAMP | LogMessageRecord::LOG_ERROR_LEVEL),
866 #endif
867  namingNode(name)
868  {
869  // replace ioMgr processing routine with new one
870  // that forwards to interested clients.
871  // NOTE: bfrMgr is from the base class
873 #ifndef _WIN32
874  -1,
875 #else
877 #endif
879  }
880 
882 
884  interestedClients.insert(client);
885  }
886 }; // end HTTPnotificationPublisher
887 
888 
892 // TODO: could templatize on max lines of history or make lineContent a vector
894 {
895 protected:
896  enum { MAX_LINES_HISTORY = 8192 };
897  struct {
898  const unsigned char *iov_base;
899  size_t iov_len;
900  char eventType[24];
903  uint32_t linesAdded;
906  std::list<HTTP_SessionRecord *> currentHTTPsessions;
907  typedef std::map<HTTPstatusRecordKey,HTTPeventStateRecord,ltHTTPstatusRecordKey> statusEventMap_t;
909 
910 protected:
914  static int forwardBuffer(SharedBufferAllocRecord *rec, IO_Processor *controller);
915 
916  int dumpLinesFromTime(HTTP_SessionRecord *rec, uint64_t fromTime);
917 
918  int dumpEventsFromTime(HTTP_SessionRecord *rec, uint64_t fromTime);
919 
920 public:
928  static void becomeEventStream(HTTP_SessionRecord *session, HTTPstatusLog *statusLog);
929 
931  sessionMutex("HTTPstatusLog")
932  {
933  linesAdded = 0;
935  for(uint32_t i=0;i<MAX_LINES_HISTORY;i+=1) {
936  lineContent[i].iov_base = nullptr;
937  }
938  }
939 
940  virtual ~HTTPstatusLog() {}
941 
942  /* NOTE: this implementation uses the hijacked IO_Processor. It
943  * generates a copy of the formatted data into a buffer record and
944  * notifies the processing thread of its availability.
945  * \return the number of bytes processed.
946  */
947  int emitLineAsHTTPevent(IO_Processor *controller, uint64_t eventId,
948  const char *eventType,
949  const unsigned char *lineData, uint32_t lineLen,
950  const char *additional);
951 
952  int emitLogLineAsHTTPevent(IO_Processor *controller, uint32_t relLine, const char *additional)
953  {
954  const unsigned char *data = const_cast<unsigned char *>(lineContent[relLine].iov_base);
955  uint32_t lineLen = (uint32_t) lineContent[relLine].iov_len;
956  int rc = emitLineAsHTTPevent(controller, relLine,
957  lineContent[relLine].eventType,
958  data, lineLen, additional);
959  return (rc);
960  }
961 
962  void addHTTPsession(HTTP_SessionRecord *rec, uint64_t fromTime=0);
963 
965 
966  virtual void receiveNotice(const unsigned char *bfr, uint32_t bfrLen,
967  const char *eventType="log") override;
968 
972  const HTTPeventStateRecord *locateEventRecord(const void *obj, const char *eventType) const;
973 
980  HTTPeventStateRecord *findOrCreateEventRecord(const void *obj, const char *eventType);
981 
982  void publishEventState(const HTTPeventStateRecord *rec);
983 
984  void publishKeepAlive();
985 
986 }; // end class HTTPstatusLog
987 
988 
990 #endif
991 /* vim: set expandtab shiftwidth=4 tabstop=4: */
HTTPembeddedServerBase
Core embedded HTTP server logic.
Definition: HTTPembeddedServer.hpp:606
Parse_And_Process_HTTP_Stream::contentLengthWanted
int32_t contentLengthWanted
Definition: read_file.hpp:602
HTTPnotificationPublisher::HTTPnotificationPublisher
HTTPnotificationPublisher(const char *name)
Definition: HTTPembeddedServer.hpp:859
IO_Processor::PROCESS_THREAD
@ PROCESS_THREAD
Definition: io_processor.hpp:160
safe_strcpy
#define safe_strcpy(d, s, l)
Safe strcpy() routine that will not copy more than l bytes and always ensures that a null is present ...
Definition: compiler_hints.h:696
EALEN
#define EALEN
Definition: getether.c:25
HTTPembeddedServerBase::~HTTPembeddedServerBase
virtual ~HTTPembeddedServerBase()
Definition: HTTPembeddedServer.hpp:684
HTTPembeddedServerBase::setBufferSize
void setBufferSize(uint32_t bfrSize)
Alter buffer size used for new accepted client connections.
Definition: HTTPembeddedServer.hpp:688
IO_Processor_Statistics::packetsProcessed
SMV_StandaloneNumeric< uint32_t > packetsProcessed
Definition: io_processor.hpp:127
GenericSocketAddress::socketAddress
union GenericSocketAddress::GenericSocketAddress_union socketAddress
IFLOG_WHEN
#define IFLOG_WHEN(lvl)
Convenience declaration for log line that will be conditionally emitted for the default component if ...
Definition: logging_api.hpp:2941
IO_Processor::statistics
IO_Processor_Statistics * statistics
statistics
Definition: io_processor.hpp:195
l
Ïúíþ ð Ø ˜ ˜ __text __TEXT € __apple_names __DWARF __apple_objc __DWARF __apple_namespac__DWARF H X __apple_types __DWARF l
Definition: tmp3.o.cpp:1
IO_Processor
Intermediary I/O processing object for performing multi-threaded receive-and-process operations on a ...
Definition: io_processor.hpp:154
LogManager::ioMgr
IO_Processor * ioMgr
Definition: logging_api.hpp:598
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const struct sockaddr_in6 ipv6) OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:165
LogManager::bfrMgr
BufferRegion * bfrMgr
Definition: logging_api.hpp:597
GenericSocketAddress::getAddressAndPort
char * getAddressAndPort(char *bfr, uint32_t bfrSize, bool includeURLprefix=false) const
Convenience cover to copyAddressAndPort() that concatenates the port to the result.
Definition: HTTPembeddedServer.hpp:291
read_file.hpp
FARGOS file processing infrastructure.
HTTPstatusLog::~HTTPstatusLog
virtual ~HTTPstatusLog()
Definition: HTTPembeddedServer.hpp:940
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const std::string &address, uint16_t port)
Definition: HTTPembeddedServer.hpp:188
HTTP_SessionRecord
Per-session HTTP state record.
Definition: HTTPembeddedServer.hpp:378
HTTPstatusLog::sessionMutex
TimedMutex sessionMutex
Definition: HTTPembeddedServer.hpp:905
HTTPembeddedServer::HTTPembeddedServer
HTTPembeddedServer(uint16_t port, USER_CLASS *extraData=0, const char *useServerName=0, uint32_t useBfrSize=0, uint16_t maxEventLen=0)
Definition: HTTPembeddedServer.hpp:740
OS_SOCKET_TYPE
#define OS_SOCKET_TYPE
Definition: io_processor.hpp:41
io_processor.hpp
FARGOS I/O Processing classes.
Parse_And_Process_HTTP_Stream::READ_REQUEST
@ READ_REQUEST
Definition: read_file.hpp:588
fromHex
#define fromHex(x)
Definition: HTTPembeddedServer.cpp:31
HTTPembeddedServerBase::listenDescriptor
OS_SOCKET_TYPE listenDescriptor
Definition: HTTPembeddedServer.hpp:617
HTTPembeddedServer::acceptNewConnection
virtual HTTP_SessionRecord * acceptNewConnection(IO_Processor *io, CircularBufferManager *mgr, const GenericSocketAddress *from, void *extraData)
Definition: HTTPembeddedServer.hpp:748
GenericSocketAddress::addressLength
uint8_t addressLength
Definition: HTTPembeddedServer.hpp:36
SharedBufferAllocRecord_32
Allocation record for chains in a 32-bit shared memory buffer.
Definition: circular_bfr.hpp:103
IO_Processor::getExtraData
void * getExtraData() const OME_ALWAYS_INLINE
Retrieve extra information value.
Definition: io_processor.hpp:334
TimedMutex::unlock
int64_t unlock()
Release a previously locked mutex.
Definition: timed_mutex.cpp:156
HTTPembeddedServerBase::startHTTPlisten
int startHTTPlisten()
Start the HTTP server.
Definition: HTTPembeddedServer.cpp:384
HTTPnotificationReceiverInterface::receiveNotice
virtual void receiveNotice(const unsigned char *bfr, uint32_t bfrLen, const char *eventType="log")=0
Abstract interface to deliver formatted message.
SIGPIPE
#define SIGPIPE
Definition: tmp.o.cpp:529
HTTPstatusRecordKey
Key structure for imposing a partial order on HTTP status events.
Definition: HTTPembeddedServer.hpp:802
HTTP_SessionRecord::httpRequestHandlerTable
std::map< std::string, HTTPcallbackFP > httpRequestHandlerTable
Definition: HTTPembeddedServer.hpp:403
IO_Processor::bufferAddress
unsigned char * bufferAddress(SharedBufferAllocRecord *rec, size_t *bufferLen=nullptr) const OME_ALWAYS_INLINE
Return physical address of a buffer within the context of the local process' address space.
Definition: io_processor.hpp:275
HTTPnotificationReceiverInterface
Abstract interface to receive log message for transmission to HTTP-attached clients.
Definition: HTTPembeddedServer.hpp:828
HTTPembeddedServerBase::serverName
char serverName[64]
Definition: HTTPembeddedServer.hpp:608
HTTPnotificationPublisher::interestedClients
std::set< HTTPnotificationReceiverInterface * > interestedClients
Definition: HTTPembeddedServer.hpp:854
BufferRegion::OWN_BLOCK
@ OWN_BLOCK
indicates region is owned by the BufferRegion and should be recovered when deleted.
Definition: circular_bfr.hpp:181
HTTP_SessionRecord::~HTTP_SessionRecord
~HTTP_SessionRecord()
Definition: HTTPembeddedServer.hpp:456
HTTPembeddedServer
Templatized embedded HTTP server interface; realizes a complete implementation of HTTPembeddedServerB...
Definition: HTTPembeddedServer.hpp:737
HTTP_SessionRecord::closeWhenRequestComplete
bool closeWhenRequestComplete
Definition: HTTPembeddedServer.hpp:401
HTTP_SessionRecord::default_OPTIONS
static int default_OPTIONS(HTTP_SessionRecord *session, const char *cmd, char *url, unsigned char *block, size_t blockLen)
Default implementation to handle OPTIONS request. It emits Access-Control-Allow headers,...
Definition: HTTPembeddedServer.cpp:197
HTTP_SessionRecord::ltCharPtrStr::operator()
bool operator()(const char *arg1, const char *arg2) const
Definition: HTTPembeddedServer.hpp:382
HTTPembeddedServer::getUserData
USER_CLASS * getUserData() const
Returns the user-specific data as a typed value.
Definition: HTTPembeddedServer.hpp:757
VIRTUAL_OVERRIDE
#define VIRTUAL_OVERRIDE
Generates override if the compiler supports it.
Definition: compiler_hints.h:435
SharedMemoryVariableNode
Intermediate naming node for supporting variable naming hierarchies.
Definition: shared_variable.hpp:318
IO_Processor_Statistics::bytesRead
SMV_StandaloneNumeric< uint64_t > bytesRead
Definition: io_processor.hpp:122
HTTPembeddedServerBase::waitForHTTPstop
int waitForHTTPstop()
Wait for server to cease operations.
Definition: HTTPembeddedServer.cpp:457
GenericSocketAddress::GenericSocketAddress_union
Definition: HTTPembeddedServer.hpp:27
io
LogMaskType_t COMPONENT_LOG_MASK() io("io_logMask", &DEFAULT_sharedMemoryVariableManager, COMPONENT_LEVEL(io, warn)|COMPONENT_LEVEL(io, error)|COMPONENT_LEVEL(io, fatal))
HTTPeventStateRecord
Internal record to describe events to be published via HTTP.
Definition: HTTPembeddedServer.hpp:770
_INVALID_DESCRIPTOR
#define _INVALID_DESCRIPTOR
Platform-independent reference to invalid descriptor.
Definition: logging_api.hpp:2618
INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE
Definition: poll_monitor.hpp:19
GenericSocketAddress::operator=
GenericSocketAddress & operator=(const struct sockaddr_in ipv4) OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:192
SIGIO
#define SIGIO
Definition: tmp.o.cpp:526
HTTPstatusLog::addHTTPsession
void addHTTPsession(HTTP_SessionRecord *rec, uint64_t fromTime=0)
Definition: HTTPembeddedServer.cpp:576
GenericSocketAddress::GenericSocketAddress_union::filename
struct sockaddr_un filename
Definition: HTTPembeddedServer.hpp:33
HTTPstatusRecordKey::object
const void * object
Definition: HTTPembeddedServer.hpp:803
HTTP_SessionRecord::setCloseAfterRequestFlag
void setCloseAfterRequestFlag(bool doClose)
Set close-when-request-complete flag.
Definition: HTTPembeddedServer.hpp:512
operator<<
STREAMTYPE & operator<<(STREAMTYPE &os, const GenericSocketAddress &arg)
Definition: HTTPembeddedServer.hpp:358
HTTPembeddedServerBase::setHTTPeventLength
void setHTTPeventLength(uint32_t maxLen)
Alter maximum length of an HTTP event used for new accepted connections.
Definition: HTTPembeddedServer.hpp:694
HTTPembeddedServer.hpp
FARGOS Embedded HTTP server.
HTTP_SessionRecord::sendResponse
ssize_t sendResponse(const void *bfr, size_t bfrLen)
Definition: HTTPembeddedServer.cpp:147
HTTP_SessionRecord::convertHTTPescapes
static char * convertHTTPescapes(char *bfr, int_fast32_t bfrLen=-1, bool nullTerminate=false)
Definition: HTTPembeddedServer.cpp:35
HTTPnotificationPublisher::~HTTPnotificationPublisher
virtual ~HTTPnotificationPublisher()
Definition: HTTPembeddedServer.hpp:881
HTTPembeddedServerBase::stopHTTPlisten
int stopHTTPlisten(const char *reason)
Stop the HTTP server.
Definition: HTTPembeddedServer.cpp:442
HTTPembeddedServerBase::readHTTPstream
static int readHTTPstream(SharedBufferAllocRecord *rec, IO_Processor *controller)
Definition: HTTPembeddedServer.cpp:215
HTTPeventStateRecord::lineLength
uint32_t lineLength
Definition: HTTPembeddedServer.hpp:776
HTTPnotificationPublisher::forwardToClients
static int forwardToClients(SharedBufferAllocRecord *rec, IO_Processor *controller)
Definition: HTTPembeddedServer.cpp:720
ntohs
#define ntohs(x)
Definition: tmp.o.cpp:3103
HTTPnotificationPublisher
Base class for converting a LogManager into a publisher that outputs log event messages to multiple a...
Definition: HTTPembeddedServer.hpp:851
HTTPeventStateRecord::eventRecordId
uint32_t eventRecordId
Definition: HTTPembeddedServer.hpp:777
Parse_And_Process_HTTP_Stream
Scan HTTP and parse stream for HTTP requests/responses.
Definition: read_file.hpp:584
SIG_BLOCK
#define SIG_BLOCK
Definition: tmp.o.cpp:550
ltHTTPstatusRecordKey
Implements Less-than for HTTPstatusRecordKey.
Definition: HTTPembeddedServer.hpp:809
GenericSocketAddress::setFromHostAndPort
int setFromHostAndPort(const char *targetAddress, uint16_t port)
Assign from an URL representation of the address and an integer value of the port....
Definition: HTTPembeddedServer.hpp:54
HTTPnotificationReceiverInterface::~HTTPnotificationReceiverInterface
~HTTPnotificationReceiverInterface()
Definition: HTTPembeddedServer.hpp:833
GenericSocketAddress::GenericSocketAddress_union::ipv6
struct sockaddr_in6 ipv6
Definition: HTTPembeddedServer.hpp:31
HTTPembeddedServerBase::listenPort
uint16_t listenPort
Definition: HTTPembeddedServer.hpp:620
GenericSocketAddress::copyAddressAndPort
int copyAddressAndPort(char *addrText, uint32_t bfrSize, bool includeURLprefix=false) const
Return the address as a URL.
Definition: HTTPembeddedServer.hpp:215
AS_ESCAPED_TEXT_BUFFER
#define AS_ESCAPED_TEXT_BUFFER(...)
Convenience label to enable passing text with known length to output operator<<().
Definition: logging_api.hpp:2100
HTTPstatusLog::eventType
char eventType[24]
Definition: HTTPembeddedServer.hpp:900
IO_Processor::setThreadMode
int setThreadMode(ThreadMode mode)
Set threading mode.
Definition: io_processor.cpp:564
HTTPembeddedServerBase::userData
void * userData
Definition: HTTPembeddedServer.hpp:616
Parse_And_Process_HTTP_Stream::httpRequest
char httpRequest[16]
Definition: read_file.hpp:600
srcID
const char srcID[]
Definition: catSym.c:17
SOCKET_CAST
#define SOCKET_CAST(x)
Definition: HTTPembeddedServer.cpp:22
HTTPstatusLog::becomeEventStream
static void becomeEventStream(HTTP_SessionRecord *session, HTTPstatusLog *statusLog)
Static convenience routine to take over an existing HTTP session and turn it into an event forwarder ...
Definition: HTTPembeddedServer.cpp:761
GenericSocketAddress::operator==
bool operator==(const GenericSocketAddress &arg) const OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:303
GenericSocketAddress::operator>
bool operator>(const GenericSocketAddress &arg) const OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:337
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress() OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:156
HTTPstatusLog::currentHTTPsessions
std::list< HTTP_SessionRecord * > currentHTTPsessions
Definition: HTTPembeddedServer.hpp:906
IO_Processor::READ_AND_PROCESS_ON_SAME_THREAD
@ READ_AND_PROCESS_ON_SAME_THREAD
a single spawned read thread will do both read-and-processing
Definition: io_processor.hpp:167
IO_Processor::descriptor
OS_HANDLE_TYPE descriptor
Definition: io_processor.hpp:210
HTTPeventStateRecord::eventType
char eventType[24]
Definition: HTTPembeddedServer.hpp:778
Parse_And_Process_HTTP_Stream::requestURL
char requestURL[1024]
Definition: read_file.hpp:601
HTTP_SessionRecord::prepareResponseHeader
int_fast32_t prepareResponseHeader(void *outputBfr, size_t bfrLen, uint_fast32_t statusCodeValue=200, const char *statusText="OK", const char *extraHeaders="", ssize_t contentLength=0, const char *extraContent="")
Definition: HTTPembeddedServer.cpp:132
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const struct sockaddr_in ipv4) OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:160
LogManager
Implements multi-threaded, deferred physical I/O log file manager.
Definition: logging_api.hpp:552
HTTPembeddedServerBase::bufferSize
uint32_t bufferSize
Definition: HTTPembeddedServer.hpp:618
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const struct sockaddr *generic_addr, socklen_t addrLen) OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:174
IO_Processor::doConsumeLoop
static int doConsumeLoop(IO_Processor *controller)
Standard consume loop to receive incoming data.
Definition: io_processor.cpp:172
OME_EXPECT_TRUE
#define OME_EXPECT_TRUE(expr)
Annotation macro for conditional expression expected to be true.
Definition: compiler_hints.h:541
IO_Processor::waitForThreadExit
int waitForThreadExit(uint32_t modes)
Wait for threads to terminate.
Definition: io_processor.cpp:728
IO_Processor_Statistics::packetsRead
SMV_StandaloneNumeric< uint32_t > packetsRead
Definition: io_processor.hpp:125
GenericSocketAddress::operator!=
bool operator!=(const GenericSocketAddress &arg) const OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:311
HTTPembeddedServerBase::startHTTPacceptThread
static void * startHTTPacceptThread(void *arg)
Definition: HTTPembeddedServer.cpp:261
BufferRegion::allocateBlock
virtual SharedBufferAllocRecord * allocateBlock(size_t len)=0
HTTPstatusLog::iov_len
size_t iov_len
Definition: HTTPembeddedServer.hpp:899
IO_Processor::stopThread
int stopThread(uint32_t modes)
Request stop.
Definition: io_processor.cpp:684
HTTP_SessionRecord::bfrMgr
CircularBufferManager * bfrMgr
Definition: HTTPembeddedServer.hpp:398
text2uint32
uint_fast32_t text2uint32(const char *textString, uint_fast8_t text_len) NONNULL_PARAMETERS(1) OME_ALWAYS_INLINE OME_ALWAYS_OPTIMIZE("-O3")
Convert a sequence of text characters into an unsigned integer as quickly as possible....
Definition: text2int.h:79
IO_Processor::PROCESS_DURING_READ
@ PROCESS_DURING_READ
Processing will be performed by the read thread.
Definition: io_processor.hpp:162
TimedMutex
Generic mutex implementation that supports timing statistics.
Definition: timed_mutex.hpp:51
HTTP_SessionRecord::fromAddress
GenericSocketAddress fromAddress
Definition: HTTPembeddedServer.hpp:400
GenericSocketAddress::operator=
GenericSocketAddress & operator=(const struct sockaddr_in6 ipv6) OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:198
HTTPstatusLog::dumpLinesFromTime
int dumpLinesFromTime(HTTP_SessionRecord *rec, uint64_t fromTime)
Definition: HTTPembeddedServer.cpp:528
HTTPembeddedServerBase::stopAccepting
bool stopAccepting
Definition: HTTPembeddedServer.hpp:621
PTHREAD_CREATE_JOINABLE
#define PTHREAD_CREATE_JOINABLE
Definition: tmp.o.cpp:425
HTTP_SessionRecord::ltCharPtrStr
Definition: HTTPembeddedServer.hpp:381
NULL
#define NULL
Definition: tmp.o.cpp:327
HTTP_SessionRecord::controller
IO_Processor * controller
Definition: HTTPembeddedServer.hpp:397
app
LogMaskType_t COMPONENT_LOG_MASK() app("app_logMask", &DEFAULT_sharedMemoryVariableManager, COMPONENT_LEVEL(app, defaultMask))
htons
#define htons(x)
Definition: tmp.o.cpp:3100
HTTPstatusLog::MAX_LINES_HISTORY
@ MAX_LINES_HISTORY
Definition: HTTPembeddedServer.hpp:896
LogMessageRecord
Log message record used to remember output format and argument values, potentially deferring formatti...
Definition: logging_api.hpp:1022
HTTPstatusRecordKey::eventType
char eventType[32]
Definition: HTTPembeddedServer.hpp:804
HTTPeventStateRecord::HTTPeventStateRecord
HTTPeventStateRecord(uint32_t id=0)
Definition: HTTPembeddedServer.hpp:781
GenericSocketAddress::setFromURL
int setFromURL(const char *addressString)
Convenience cover to setFromHostAndPort() that also converts the port.
Definition: HTTPembeddedServer.hpp:121
HTTPstatusLog::dumpEventsFromTime
int dumpEventsFromTime(HTTP_SessionRecord *rec, uint64_t fromTime)
Definition: HTTPembeddedServer.cpp:554
HTTP_SessionRecord::parseOptions
static int_fast32_t parseOptions(OptionsAttrValMap_t *tbl, char *optionText, int_fast32_t optionLength=-1)
Parse an HTTP request option string. Elements are separated by "&" characters; each subelement is exp...
Definition: HTTPembeddedServer.cpp:59
IO_Processor::NONE
@ NONE
No threads will be spawned.
Definition: io_processor.hpp:158
OME_USED
const char srcID[] OME_USED
Definition: tick_time.cpp:24
HTTPstatusLog::findOrCreateEventRecord
HTTPeventStateRecord * findOrCreateEventRecord(const void *obj, const char *eventType)
Find an event state record for the indicated object and event type.
Definition: HTTPembeddedServer.cpp:642
HTTPstatusLog::publishKeepAlive
void publishKeepAlive()
Definition: HTTPembeddedServer.cpp:665
HTTPnotificationPublisher::addInterestedClient
void addInterestedClient(HTTPnotificationReceiverInterface *client)
Definition: HTTPembeddedServer.hpp:883
IO_Processor::READ_THREAD
@ READ_THREAD
A read thread will be spawned.
Definition: io_processor.hpp:159
HTTPstatusLog::lineAddedAtTime
time_t lineAddedAtTime[MAX_LINES_HISTORY]
Definition: HTTPembeddedServer.hpp:902
HTTPstatusLog::iov_base
const unsigned char * iov_base
Definition: HTTPembeddedServer.hpp:898
HTTPstatusLog::receiveNotice
virtual void receiveNotice(const unsigned char *bfr, uint32_t bfrLen, const char *eventType="log") override
Abstract interface to deliver formatted message.
Definition: HTTPembeddedServer.cpp:599
Parse_And_Process_HTTP_Stream::processHTTPheader
virtual int processHTTPheader(unsigned char *line, size_t lineLen)
User exit for HTTP header line.
Definition: read_file.hpp:732
HTTP_SessionRecord::HTTPcallbackFP
ssize_t(* HTTPcallbackFP)(HTTP_SessionRecord *session, const char *cmd, char *url, unsigned char *block, size_t blockLen)
Signature for HTTP callback routine.
Definition: HTTPembeddedServer.hpp:391
GenericSocketAddress::GenericSocketAddress_union::bytes
unsigned char bytes[63]
Definition: HTTPembeddedServer.hpp:28
HTTP_SessionRecord::connectionEOF
virtual void connectionEOF()
User-exit called when EOF reached on client connection.
Definition: HTTPembeddedServer.hpp:522
ltHTTPstatusRecordKey::operator()
bool operator()(const HTTPstatusRecordKey &arg1, const HTTPstatusRecordKey &arg2) const
Definition: HTTPembeddedServer.hpp:811
AS_TEXT_BUFFER
#define AS_TEXT_BUFFER(s,...)
Convenience label to enable passing text with known length to output operator<<().
Definition: logging_api.hpp:2087
HTTPstatusLog::removeHTTPsession
void removeHTTPsession(HTTP_SessionRecord *rec)
Definition: HTTPembeddedServer.cpp:587
atomic_values.h
Atomic operations.
HTTPembeddedServerBase::acceptThreadID
pthread_t acceptThreadID
Definition: HTTPembeddedServer.hpp:612
CircularBufferManager
Impose a circular buffer on a BufferRegion.
Definition: circular_bfr.hpp:330
HTTP_SessionRecord::HTTP_SessionRecord
HTTP_SessionRecord(IO_Processor *io, CircularBufferManager *mgr, const GenericSocketAddress *from, void *extraData=nullptr, size_t maxDocSize=1024 *128)
Create state record for current HTTP session.
Definition: HTTPembeddedServer.hpp:442
errno
int errno
Definition: ethers.c:41
LOG_ERR
#define LOG_ERR
Definition: getether.c:23
HTTP_SessionRecord::OptionsAttrValMap_t
std::map< const char *, const char *, ltCharPtrStr > OptionsAttrValMap_t
Definition: HTTPembeddedServer.hpp:395
OME_EXPECT_FALSE
#define OME_EXPECT_FALSE(expr)
Annotation macro for conditional expression expected to be false.
Definition: compiler_hints.h:540
LOG_COMPONENT_CERR
#define LOG_COMPONENT_CERR(component, lvl)
Convenience macro that uses LOG_COMPONENT_INTO to conditionally log a message to standard error.
Definition: logging_api.hpp:3030
SharedBufferAllocRecord_32::usedLen
uint32_t usedLen
Definition: circular_bfr.hpp:107
HTTPembeddedServerBase::maxHTTPeventLength
uint16_t maxHTTPeventLength
Definition: HTTPembeddedServer.hpp:619
GenericSocketAddress::GenericSocketAddress_union::genericAddr
struct sockaddr genericAddr
Definition: HTTPembeddedServer.hpp:29
OME_ALWAYS_INLINE
#define OME_ALWAYS_INLINE
Tell the compiler to alway inline a function, regardless of optimization level.
Definition: compiler_hints.h:364
GenericSocketAddress::operator<
bool operator<(const GenericSocketAddress &arg) const OME_ALWAYS_INLINE
Definition: HTTPembeddedServer.hpp:319
HTTPembeddedServerBase::acceptNewConnection
virtual HTTP_SessionRecord * acceptNewConnection(IO_Processor *io, CircularBufferManager *mgr, const GenericSocketAddress *from, void *extraData)=0
HTTP_SessionRecord::addHTTPhandler
void addHTTPhandler(const char *cmd, HTTPcallbackFP routine)
Add a handler routine for an HTTP request command.
Definition: HTTPembeddedServer.hpp:500
report
#define report
Definition: getether.c:14
SharedBufferAllocRecord_32::blockLen
uint32_t blockLen
Definition: circular_bfr.hpp:106
HTTPstatusLog::HTTPstatusLog
HTTPstatusLog()
Definition: HTTPembeddedServer.hpp:930
HTTPstatusLog::emitLogLineAsHTTPevent
int emitLogLineAsHTTPevent(IO_Processor *controller, uint32_t relLine, const char *additional)
Definition: HTTPembeddedServer.hpp:952
HTTP_SessionRecord::interestedInEvent
virtual bool interestedInEvent(const class HTTPeventStateRecord *record)
User-exit to filter out events when session has been converted into use with an HTTPstatusLog object.
Definition: HTTPembeddedServer.hpp:574
IO_Processor::waitForThreadStart
int waitForThreadStart(uint32_t mode)
Wait for threads to start.
Definition: io_processor.cpp:712
HTTPstatusLog::emitLineAsHTTPevent
int emitLineAsHTTPevent(IO_Processor *controller, uint64_t eventId, const char *eventType, const unsigned char *lineData, uint32_t lineLen, const char *additional)
Definition: HTTPembeddedServer.cpp:473
IO_Processor::noteDataToProcess
int noteDataToProcess(bool alreadyLocked=false)
Note new data has arrived.
Definition: io_processor.cpp:803
BufferRegion::setOwnership
void setOwnership(OwnershipState newOwnership)
Change administrative ownership of region.
Definition: circular_bfr.hpp:232
GenericSocketAddress::GenericSocketAddress_union::ipv4
struct sockaddr_in ipv4
Definition: HTTPembeddedServer.hpp:30
Extract_And_Process_Document_Stream::addIOblockThenProcess
int addIOblockThenProcess(SharedBufferAllocRecord *rec, IO_Processor *controller)
Specialized interface to add incoming block from BufferRegion maintained by an IO_Processor....
Definition: read_file.hpp:541
Parse_And_Process_HTTP_Stream::httpVersion
char httpVersion[16]
Definition: read_file.hpp:597
HTTPnotificationReceiverInterface::HTTPnotificationReceiverInterface
HTTPnotificationReceiverInterface()
Definition: HTTPembeddedServer.hpp:831
IO_Processor::bfrManager
BufferRegion * bfrManager
buffer region
Definition: io_processor.hpp:194
LOG_ENDLINE
#define LOG_ENDLINE
Closing clause for text line output using << operators.
Definition: logging_api.hpp:2956
HTTP_SessionRecord::handleHTTPrequest
virtual ssize_t handleHTTPrequest(unsigned char *block, size_t blockLen)
User-exit called when HTTP request read. Not normally overridden.
Definition: HTTPembeddedServer.cpp:155
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const char *addressString)
Definition: HTTPembeddedServer.hpp:170
HTTP_SessionRecord::userData
void * userData
Definition: HTTPembeddedServer.hpp:399
HTTPstatusLog::statusEvents
statusEventMap_t statusEvents
Definition: HTTPembeddedServer.hpp:908
IO_Processor::CONTIGUOUS_BYTE_STREAM
@ CONTIGUOUS_BYTE_STREAM
contiguous byte stream from socket
Definition: io_processor.hpp:183
IO_Processor::desiredThreadState
unsigned char desiredThreadState
Definition: io_processor.hpp:218
IO_Processor::setProcessRoutine
void setProcessRoutine(IO_processBlockFP func) OME_ALWAYS_INLINE
Set processing routine.
Definition: io_processor.hpp:344
OS_HANDLE_TYPE
#define OS_HANDLE_TYPE
Definition: io_processor.hpp:48
HTTP_SessionRecord::closeConnection
void closeConnection()
Close the connection associated with this HTTP session.
Definition: HTTPembeddedServer.cpp:115
HTTPnotificationPublisher::namingNode
SharedMemoryVariableNode namingNode
Definition: HTTPembeddedServer.hpp:857
HTTPstatusLog::eventRecordsCreated
uint32_t eventRecordsCreated
Definition: HTTPembeddedServer.hpp:904
GenericSocketAddress
Protocol-independent representation of a socket address. IPv4, IPv6 and file domain sockets are suppo...
Definition: HTTPembeddedServer.hpp:25
HTTP_SessionRecord::processHTTPheader
virtual int processHTTPheader(unsigned char *line, size_t lineLen) VIRTUAL_OVERRIDE
User exit to process incoming HTTP header.
Definition: HTTPembeddedServer.hpp:547
HTTP_SessionRecord::processBlock
virtual int_fast32_t processBlock(unsigned char *blockStart, size_t blockLen) VIRTUAL_OVERRIDE
User-exit for receiving POSTed data.
Definition: HTTPembeddedServer.hpp:535
HTTPembeddedServerBase::HTTPembeddedServerBase
HTTPembeddedServerBase(uint16_t port, void *extraData=nullptr, const char *useServerName=nullptr, uint32_t useBfrSize=0, uint16_t maxEventLength=0)
Configures the HTTP server for listening on the indicated port.
Definition: HTTPembeddedServer.hpp:650
Parse_And_Process_HTTP_Stream::findHeaderAttribute
const char * findHeaderAttribute(const char *headerElement) const
Definition: read_file.hpp:620
IO_Processor::BOTH_THREADS
@ BOTH_THREADS
Both a read and a processing thread will be spawned.
Definition: io_processor.hpp:164
setLabelForThread
void setLabelForThread(pthread_t threadId, const char *label)
Definition: io_processor.cpp:51
HTTPembeddedServer::~HTTPembeddedServer
virtual ~HTTPembeddedServer()
Definition: HTTPembeddedServer.hpp:746
SA_SIGINFO
#define SA_SIGINFO
Definition: tmp.o.cpp:494
HTTPstatusLog::statusEventMap_t
std::map< HTTPstatusRecordKey, HTTPeventStateRecord, ltHTTPstatusRecordKey > statusEventMap_t
Definition: HTTPembeddedServer.hpp:907
HTTPstatusLog::locateEventRecord
const HTTPeventStateRecord * locateEventRecord(const void *obj, const char *eventType) const
Find an event state record for the indicated object and event type.
Definition: HTTPembeddedServer.cpp:626
HTTPstatusLog::linesAdded
uint32_t linesAdded
Definition: HTTPembeddedServer.hpp:903
HTTPeventStateRecord::extraData
const void * extraData
Definition: HTTPembeddedServer.hpp:774
HTTPstatusLog
Implements HTTPnotificationReceiverInterface to maintain a history of events and log lines which are ...
Definition: HTTPembeddedServer.hpp:893
HTTPembeddedServerBase::getServerName
const char * getServerName() const
Returns the name associated with the HTTP server.
Definition: HTTPembeddedServer.hpp:700
fd
int fd
Definition: ethers.c:41
HTTPeventStateRecord::MAX_STATUS_LINE_LENGTH
@ MAX_STATUS_LINE_LENGTH
Definition: HTTPembeddedServer.hpp:773
HTTPembeddedServerBase::listenActive
bool listenActive
Definition: HTTPembeddedServer.hpp:622
HTTPeventStateRecord::updateTime
uint64_t updateTime
Definition: HTTPembeddedServer.hpp:775
IO_Processor::recvConsume
static ssize_t recvConsume(SharedBufferAllocRecord *rec, class IO_Processor *controller)
Definition: io_processor.cpp:279
HTTPeventStateRecord::lineData
char lineData[MAX_STATUS_LINE_LENGTH]
Definition: HTTPembeddedServer.hpp:779
HTTPstatusLog::lineContent
struct HTTPstatusLog::@7 lineContent[MAX_LINES_HISTORY]
GenericSocketAddress::GenericSocketAddress
GenericSocketAddress(const char *address, uint16_t port)
Definition: HTTPembeddedServer.hpp:184
HTTPstatusLog::forwardBuffer
static int forwardBuffer(SharedBufferAllocRecord *rec, IO_Processor *controller)
IO_Processor-compatible processing routine used to forward buffer contents to a connect client.
Definition: HTTPembeddedServer.cpp:739
HTTPstatusLog::publishEventState
void publishEventState(const HTTPeventStateRecord *rec)
Definition: HTTPembeddedServer.cpp:687
LOG_CERR
#define LOG_CERR(lvl)
Convenience macro that uses LOG_INTO() to conditionally log a message to standard error.
Definition: logging_api.hpp:3014
EINTR
#define EINTR
Definition: tmp.o.cpp:93
Generated: Tue Jul 28 2020 16:03:25
Support Information