src/modules/extra/m_ziplink.cpp

   1 #include <string>
   2 #include <vector>
   3
   4 #include "zlib.h"
   5
   6 #include "inspircd_config.h"
   7 #include "configreader.h"
   8 #include "users.h"
   9 #include "channels.h"
  10 #include "modules.h"
  11
  12 #include "socket.h"
  13 #include "hashcomp.h"
  14 #include "inspircd.h"
  15
  16 #include "ssl.h"
  17
  18 /* $ModDesc: Provides zlib link support for servers */
  19 /* $LinkerFlags: -lz */
  20 /* $ModDep: ssl.h */
  21
  22
  23 enum izip_status { IZIP_WAITFIRST, IZIP_OPEN, IZIP_CLOSED };
  24
  25 const unsigned int CHUNK = 16384;
  26
  27 /** Represents an ZIP user's extra data
  28  */
  29 class izip_session : public classbase
  30 {
  31  public:
  32         z_stream c_stream; /* compression stream */
  33         z_stream d_stream; /* decompress stream */
  34         izip_status status;
  35         int fd;
  36 };
  37
  38 class ModuleZLib : public Module
  39 {
  40         izip_session sessions[MAX_DESCRIPTORS];
  41
  42  public:
  43
  44         ModuleZLib(InspIRCd* Me)
  45                 : Module::Module(Me)
  46         {
  47                 ServerInstance->PublishInterface("InspSocketHook", this);
  48         }
  49
  50         virtual ~ModuleZLib()
  51         {
  52         }
  53
  54         virtual Version GetVersion()
  55         {
  56                 return Version(1, 1, 0, 0, VF_VENDOR, API_VERSION);
  57         }
  58
  59         void Implements(char* List)
  60         {
  61                 List[I_OnRawSocketConnect] = List[I_OnRawSocketAccept] = List[I_OnRawSocketClose] = List[I_OnRawSocketRead] = List[I_OnRawSocketWrite] = 1;
  62                 List[I_OnRequest] = 1;
  63         }
  64
  65         virtual char* OnRequest(Request* request)
  66         {
  67                 ISHRequest* ISR = (ISHRequest*)request;
  68                 if (strcmp("IS_NAME", request->GetId()) == 0)
  69                 {
  70                         return "gnutls";
  71                 }
  72                 else if (strcmp("IS_HOOK", request->GetId()) == 0)
  73                 {
  74                         return ServerInstance->Config->AddIOHook((Module*)this, (InspSocket*)ISR->Sock) ? (char*)"OK" : NULL;
  75                 }
  76                 else if (strcmp("IS_UNHOOK", request->GetId()) == 0)
  77                 {
  78                         return ServerInstance->Config->DelIOHook((InspSocket*)ISR->Sock) ? (char*)"OK" : NULL;
  79                 }
  80                 else if (strcmp("IS_HSDONE", request->GetId()) == 0)
  81                 {
  82                         return "OK";
  83                 }
  84                 else if (strcmp("IS_ATTACH", request->GetId()) == 0)
  85                 {
  86                         return NULL;
  87                 }
  88                 return NULL;
  89         }
  90
  91
  92         virtual void OnRawSocketAccept(int fd, const std::string &ip, int localport)
  93         {
  94                 izip_session* session = &sessions[fd];
  95
  96                 /* allocate deflate state */
  97                 session->fd = fd;
  98                 session->status = IZIP_WAITFIRST;
  99
 100                 session->c_stream.zalloc = (alloc_func)0;
 101                 session->c_stream.zfree = (free_func)0;
 102                 session->c_stream.opaque = (voidpf)0;
 103
 104                 if (deflateInit(&session->c_stream, Z_DEFAULT_COMPRESSION) != Z_OK)
 105                         return;
 106
 107                 session->d_stream.zalloc = (alloc_func)0;
 108                 session->d_stream.zfree = (free_func)0;
 109                 session->d_stream.opaque = (voidpf)0;
 110
 111                 if (deflateInit(&session->d_stream, Z_DEFAULT_COMPRESSION) != Z_OK)
 112                         return;
 113         }
 114
 115         virtual void OnRawSocketConnect(int fd)
 116         {
 117                 OnRawSocketAccept(fd, "", 0);
 118         }
 119
 120         virtual void OnRawSocketClose(int fd)
 121         {
 122                 CloseSession(&sessions[fd]);
 123         }
 124
 125         virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult)
 126         {
 127                 izip_session* session = &sessions[fd];
 128
 129                 if (session->status == IZIP_CLOSED)
 130                         return 1;
 131
 132                 readresult = read(fd, buffer, count);
 133
 134                 if (readresult > 0)
 135                 {
 136                         unsigned char uncompr[count];
 137
 138                         if(session->status != IZIP_WAITFIRST)
 139                         {
 140                                 session->d_stream.next_in  = (Bytef*)buffer;
 141                                 session->d_stream.avail_in = 0;
 142                                 session->d_stream.next_out = uncompr;
 143                                 if (inflateInit(&session->d_stream) != Z_OK)
 144                                         return -EBADF;
 145                                 session->status = IZIP_OPEN;
 146                         }
 147
 148                         while ((session->d_stream.total_out < count) && (session->d_stream.total_in < (unsigned int)readresult))
 149                         {
 150                                 session->d_stream.avail_in = session->d_stream.avail_out = 1; /* force small buffers */
 151                                 if (inflate(&session->d_stream, Z_NO_FLUSH) == Z_STREAM_END)
 152                                         break;
 153                         }
 154
 155                         readresult = session->d_stream.total_out;
 156                 }
 157                 return (readresult > 0);
 158         }
 159
 160         virtual int OnRawSocketWrite(int fd, const char* buffer, int count)
 161         {
 162                 if (!count)
 163                         return 0;
 164
 165                 unsigned char compr[count*2];
 166
 167                 izip_session* session = &sessions[fd];
 168
 169                 if(session->status != IZIP_WAITFIRST)
 170                 {
 171                         deflateInit(&session->c_stream, Z_DEFAULT_COMPRESSION);
 172                         session->status = IZIP_OPEN;
 173                 }
 174
 175                 if(session->status != IZIP_OPEN)
 176                         return 1;
 177
 178                 session->c_stream.next_in  = (Bytef*)buffer;
 179                 session->c_stream.next_out = compr;
 180
 181                 while ((session->c_stream.total_in < (unsigned int)count) && (session->c_stream.total_out < (unsigned int)count*2))
 182                 {
 183                         session->c_stream.avail_in = session->c_stream.avail_out = 1; /* force small buffers */
 184                         if (deflate(&session->c_stream, Z_NO_FLUSH) != Z_OK)
 185                                 return 0;
 186                 }
 187                 /* Finish the stream, still forcing small buffers: */
 188                 for (;;)
 189                 {
 190                         session->c_stream.avail_out = 1;
 191                         if (deflate(&session->c_stream, Z_FINISH) == Z_STREAM_END)
 192                                 break;
 193                 }
 194
 195                 return write(fd, compr, session->c_stream.total_out);
 196         }
 197
 198         void CloseSession(izip_session* session)
 199         {
 200                 if(session->status == IZIP_OPEN)
 201                 {
 202                         deflateEnd(&session->c_stream);
 203                         inflateEnd(&session->d_stream);
 204                 }
 205                 session->status = IZIP_CLOSED;
 206         }
 207
 208 };
 209
 210 class ModuleZLibFactory : public ModuleFactory
 211 {
 212  public:
 213         ModuleZLibFactory()
 214         {
 215         }
 216
 217         ~ModuleZLibFactory()
 218         {
 219         }
 220
 221         virtual Module * CreateModule(InspIRCd* Me)
 222         {
 223                 return new ModuleZLib(Me);
 224         }
 225 };
 226
 227
 228 extern "C" void * init_module( void )
 229 {
 230         return new ModuleZLibFactory;
 231 }