webcit/who.c

   1
   2 #include "webcit.h"
   3
   4 CtxType CTX_WHO = CTX_NONE;
   5
   6 typedef struct UserStateStruct {
   7         StrBuf *UserName;
   8         StrBuf *Room;
   9         StrBuf *Host;
  10         StrBuf *UserAgent;
  11         StrBuf *RealRoom;
  12         StrBuf *RealHost;
  13         long LastActive;
  14         int Session;
  15         int Idle;
  16         int IdleSince;
  17         int SessionCount;
  18 } UserStateStruct;
  19
  20 void DestroyUserStruct(void *vUser)
  21 {
  22         UserStateStruct *User = (UserStateStruct*) vUser;
  23         FreeStrBuf(&User->UserName);
  24         FreeStrBuf(&User->Room);
  25         FreeStrBuf(&User->Host);
  26         FreeStrBuf(&User->RealRoom);
  27         FreeStrBuf(&User->RealHost);
  28         FreeStrBuf(&User->UserAgent);
  29         free(User);
  30 }
  31
  32 int CompareUserStruct(const void *VUser1, const void *VUser2)
  33 {
  34         const UserStateStruct *User1 = (UserStateStruct*) GetSearchPayload(VUser1);
  35         const UserStateStruct *User2 = (UserStateStruct*) GetSearchPayload(VUser2);
  36
  37         if (User1->Idle != User2->Idle)
  38                 return User1->Idle > User2->Idle;
  39         return strcasecmp(ChrPtr(User1->UserName),
  40                           ChrPtr(User2->UserName));
  41 }
  42
  43
  44 int GetWholistSection(HashList *List, time_t now, StrBuf *Buf, const char *FilterName, long FNLen)
  45 {
  46         UserStateStruct *User, *OldUser;
  47         void *VOldUser;
  48         size_t BufLen;
  49         const char *Pos;
  50
  51         serv_puts("RWHO");
  52         StrBuf_ServGetln(Buf);
  53         if (GetServerStatus(Buf, NULL) == 1) {
  54                 while (BufLen = StrBuf_ServGetln(Buf),
  55                        ((BufLen >= 0) &&
  56                         ((BufLen != 3) || strcmp(ChrPtr(Buf), "000"))))
  57                 {
  58                         if (BufLen <= 0)
  59                             continue;
  60                         Pos = NULL;
  61                         User = (UserStateStruct*) malloc(sizeof(UserStateStruct));
  62                         User->Session = StrBufExtractNext_int(Buf, &Pos, '|');
  63
  64                         User->UserName = NewStrBufPlain(NULL, BufLen);
  65                         StrBufExtract_NextToken(User->UserName, Buf, &Pos, '|');
  66
  67                         User->Room = NewStrBufPlain(NULL, BufLen);
  68                         StrBufExtract_NextToken(User->Room, Buf, &Pos, '|');
  69
  70                         User->Host = NewStrBufPlain(NULL, BufLen);
  71                         StrBufExtract_NextToken(User->Host, Buf, &Pos, '|');
  72
  73                         User->UserAgent = NewStrBufPlain(NULL, BufLen);
  74                         StrBufExtract_NextToken(User->UserAgent, Buf, &Pos, '|');
  75
  76                         User->LastActive = StrBufExtractNext_long(Buf, &Pos, '|');
  77                         StrBufSkip_NTokenS(Buf, &Pos, '|', 3);
  78
  79                         User->RealRoom = NewStrBufPlain(NULL, BufLen);
  80                         StrBufExtract_NextToken(User->RealRoom, Buf, &Pos, '|');
  81
  82                         User->RealHost = NewStrBufPlain(NULL, BufLen);
  83                         StrBufExtract_NextToken(User->RealHost, Buf, &Pos, '|');
  84
  85                         User->Idle = (now - User->LastActive) > 900L;
  86                         User->IdleSince = (now - User->LastActive) / 60;
  87                         User->SessionCount = 1;
  88
  89                         if (FilterName == NULL) {
  90                                 if (GetHash(List,
  91                                             SKEY(User->UserName),
  92                                             &VOldUser)) {
  93                                         OldUser = VOldUser;
  94                                         OldUser->SessionCount++;
  95                                         if (!User->Idle) {
  96                                                 if (User->Session == WC->ctdl_pid)
  97                                                         OldUser->Session = User->Session;
  98
  99                                                 OldUser->Idle = User->Idle;
 100                                                 OldUser->LastActive = User->LastActive;
 101                                         }
 102                                         DestroyUserStruct(User);
 103                                 }
 104                                 else
 105                                         Put(List,
 106                                             SKEY(User->UserName),
 107                                             User, DestroyUserStruct);
 108                         }
 109                         else {
 110                                 if (strcmp(FilterName, ChrPtr(User->UserName)) == 0)
 111                                 {
 112                                         Put(List,
 113                                             SKEY(User->UserName),
 114                                             User, DestroyUserStruct);
 115                                 }
 116                                 else
 117                                 {
 118                                         DestroyUserStruct(User);
 119                                 }
 120                         }
 121                 }
 122                 if (FilterName == NULL)
 123                         SortByPayload(List, CompareUserStruct);
 124                 return 1;
 125         }
 126         else {
 127                 return 0;
 128         }
 129 }
 130
 131 /*
 132  * end session
 133  */
 134 void terminate_session(void)
 135 {
 136         char buf[SIZ];
 137
 138         serv_printf("TERM %s", bstr("which_session"));
 139         serv_getln(buf, sizeof buf);
 140         url_do_template();
 141 }
 142
 143
 144 void _terminate_session(void) {
 145         slrp_highest();
 146         terminate_session();
 147 }
 148
 149 HashList *GetWholistHash(StrBuf *Target, WCTemplputParams *TP)
 150
 151 {
 152         const char *ch = NULL;
 153         int HashUniq = 1;
 154         long len;
 155         StrBuf *FilterNameStr = NULL;
 156         StrBuf *Buf;
 157         HashList *List;
 158         time_t now;
 159
 160         Buf = NewStrBuf();
 161
 162         serv_puts("TIME");
 163         StrBuf_ServGetln(Buf);
 164         if (GetServerStatus(Buf, NULL)  == 2) {
 165                 const char *pos = ChrPtr(Buf) + 4;
 166                 now = StrBufExtractNext_long(Buf, &pos, '|');
 167         }
 168         else {
 169                 now = time(NULL);
 170         }
 171         if (HaveTemplateTokenString(NULL, TP, 2, &ch, &len))
 172         {
 173                 FilterNameStr = NewStrBuf();
 174                 GetTemplateTokenString(FilterNameStr, TP, 2, &ch, &len);
 175                 HashUniq = 0;
 176         }
 177
 178         List = NewHash(HashUniq, NULL);
 179         GetWholistSection(List, now, Buf, ch, len);
 180         FreeStrBuf(&Buf);
 181         FreeStrBuf(&FilterNameStr);
 182         return List;
 183 }
 184
 185
 186 void DeleteWholistHash(HashList **KillMe)
 187 {
 188         DeleteHash(KillMe);
 189 }
 190
 191 void tmplput_who_username(StrBuf *Target, WCTemplputParams *TP)
 192 {
 193         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 194         StrBufAppendTemplate(Target, TP, User->UserName, 0);
 195 }
 196
 197 void tmplput_who_UserAgent(StrBuf *Target, WCTemplputParams *TP)
 198 {
 199         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 200         StrBufAppendTemplate(Target, TP, User->UserAgent, 0);
 201 }
 202
 203 void tmplput_who_room(StrBuf *Target, WCTemplputParams *TP)
 204 {
 205         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 206         StrBufAppendTemplate(Target, TP, User->Room, 0);
 207 }
 208
 209 void tmplput_who_host(StrBuf *Target, WCTemplputParams *TP)
 210 {
 211         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 212         StrBufAppendTemplate(Target, TP, User->Host, 0);
 213 }
 214
 215 void tmplput_who_realroom(StrBuf *Target, WCTemplputParams *TP)
 216 {
 217         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 218         StrBufAppendTemplate(Target, TP, User->RealRoom, 0);
 219 }
 220 int conditional_who_realroom(StrBuf *Target, WCTemplputParams *TP)
 221 {
 222         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 223         return StrLength(User->RealRoom) > 0;
 224 }
 225
 226 void tmplput_who_realhost(StrBuf *Target, WCTemplputParams *TP)
 227 {
 228         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 229         StrBufAppendTemplate(Target, TP, User->RealHost, 0);
 230 }
 231 int conditional_who_realhost(StrBuf *Target, WCTemplputParams *TP)
 232 {
 233         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 234         return StrLength(User->RealHost) > 0;
 235 }
 236
 237 void tmplput_who_lastactive(StrBuf *Target, WCTemplputParams *TP)
 238 {
 239         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 240         StrBufAppendPrintf(Target, "%d", User->LastActive);
 241 }
 242
 243 void tmplput_who_idlesince(StrBuf *Target, WCTemplputParams *TP)
 244 {
 245         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 246         StrBufAppendPrintf(Target, "%d", User->IdleSince);
 247 }
 248
 249 void tmplput_who_session(StrBuf *Target, WCTemplputParams *TP)
 250 {
 251         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 252         StrBufAppendPrintf(Target, "%d", User->Session);
 253 }
 254
 255 int conditional_who_idle(StrBuf *Target, WCTemplputParams *TP)
 256 {
 257         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 258         return User->Idle;
 259 }
 260
 261 int conditional_who_nsessions(StrBuf *Target, WCTemplputParams *TP)
 262 {
 263         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 264         return User->SessionCount;
 265 }
 266
 267 void tmplput_who_nsessions(StrBuf *Target, WCTemplputParams *TP)
 268 {
 269         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 270         StrBufAppendPrintf(Target, "%d", User->SessionCount);
 271 }
 272
 273 int conditional_who_isme(StrBuf *Target, WCTemplputParams *TP)
 274 {
 275         UserStateStruct *User = (UserStateStruct*) CTX(CTX_WHO);
 276         return (User->Session == WC->ctdl_pid);
 277 }
 278
 279 void
 280 InitModule_WHO
 281 (void)
 282 {
 283         RegisterCTX(CTX_WHO);
 284
 285         WebcitAddUrlHandler(HKEY("terminate_session"), "", 0, _terminate_session, 0);
 286
 287         RegisterIterator("WHOLIST", 1, NULL, GetWholistHash, NULL, DeleteWholistHash, CTX_WHO, CTX_NONE, IT_NOFLAG);
 288
 289         RegisterNamespace("WHO:NAME",        0, 1, tmplput_who_username, NULL, CTX_WHO);
 290         RegisterNamespace("WHO:USERAGENT",   0, 1, tmplput_who_UserAgent, NULL, CTX_WHO);
 291         RegisterNamespace("WHO:ROOM",        0, 1, tmplput_who_room, NULL, CTX_WHO);
 292         RegisterNamespace("WHO:HOST",        0, 1, tmplput_who_host, NULL, CTX_WHO);
 293         RegisterNamespace("WHO:REALROOM",    0, 1, tmplput_who_realroom, NULL, CTX_WHO);
 294         RegisterNamespace("WHO:REALHOST",    0, 1, tmplput_who_realhost, NULL, CTX_WHO);
 295         RegisterNamespace("WHO:LASTACTIVE",  0, 1, tmplput_who_lastactive, NULL, CTX_WHO);
 296         RegisterNamespace("WHO:IDLESINCE",   0, 1, tmplput_who_idlesince, NULL, CTX_WHO);
 297         RegisterNamespace("WHO:SESSION",     0, 1, tmplput_who_session, NULL, CTX_WHO);
 298         RegisterNamespace("WHO:NSESSIONS",   0, 1, tmplput_who_nsessions, NULL, CTX_WHO);
 299         RegisterNamespace("WHO:NSESSIONS",   0, 1, tmplput_who_nsessions, NULL, CTX_WHO);
 300
 301         RegisterConditional("WHO:IDLE",      1, conditional_who_idle, CTX_WHO);
 302         RegisterConditional("WHO:NSESSIONS", 1, conditional_who_nsessions, CTX_WHO);
 303         RegisterConditional("WHO:ISME",      1, conditional_who_isme, CTX_WHO);
 304         RegisterConditional("WHO:REALROOM",  1, conditional_who_realroom, CTX_WHO);
 305         RegisterConditional("WHO:REALHOST",  1, conditional_who_realhost, CTX_WHO);
 306 }