/* $CompileFlags: pkgconfversion("openssl","0.9.7") pkgconfincludes("openssl","/openssl/ssl.h","") */
/* $LinkerFlags: rpath("pkg-config --libs openssl") pkgconflibs("openssl","/libssl.so","-lssl -lcrypto -ldl") */
/* $ModDep: transport.h */
+/* $NoPedantic */
enum issl_status { ISSL_NONE, ISSL_HANDSHAKING, ISSL_OPEN };
enum issl_io_status { ISSL_WRITE, ISSL_READ };
ModuleSSLOpenSSL(InspIRCd* Me)
: Module(Me), PublicInstance(Me)
{
- ServerInstance->Modules->PublishInterface("InspSocketHook", this);
+ ServerInstance->Modules->PublishInterface("BufferedSocketHook", this);
// Not rehashable...because I cba to reduce all the sizes of existing buffers.
inbufsize = ServerInstance->Config->NetBufferSize;
OnRehash(NULL,"ssl");
}
- virtual void OnRehash(userrec* user, const std::string ¶m)
+ virtual void OnRehash(User* user, const std::string ¶m)
{
if (param != "ssl")
return;
{
if (target_type == TYPE_USER)
{
- userrec* user = (userrec*)item;
+ User* user = (User*)item;
if (user->GetExt("ssl", dummy) && IS_LOCAL(user) && isin(user->GetPort(), listenports))
{
// User is using SSL, they're a local user, and they're using one of *our* SSL ports.
// Potentially there could be multiple SSL modules loaded at once on different ports.
- userrec::QuitUser(ServerInstance, user, "SSL module unloading");
+ User::QuitUser(ServerInstance, user, "SSL module unloading");
}
if (user->GetExt("ssl_cert", dummy) && isin(user->GetPort(), listenports))
{
char* ret = "OK";
try
{
- ret = ServerInstance->Config->AddIOHook((Module*)this, (InspSocket*)ISR->Sock) ? (char*)"OK" : NULL;
+ ret = ServerInstance->Config->AddIOHook((Module*)this, (BufferedSocket*)ISR->Sock) ? (char*)"OK" : NULL;
}
catch (ModuleException &e)
{
}
else if (strcmp("IS_UNHOOK", request->GetId()) == 0)
{
- return ServerInstance->Config->DelIOHook((InspSocket*)ISR->Sock) ? (char*)"OK" : NULL;
+ return ServerInstance->Config->DelIOHook((BufferedSocket*)ISR->Sock) ? (char*)"OK" : NULL;
}
else if (strcmp("IS_HSDONE", request->GetId()) == 0)
{
issl_session* session = &sessions[ISR->Sock->GetFd()];
if (session->sess)
{
- VerifyCertificate(session, (InspSocket*)ISR->Sock);
+ VerifyCertificate(session, (BufferedSocket*)ISR->Sock);
return "OK";
}
}
virtual void OnRawSocketAccept(int fd, const std::string &ip, int localport)
{
+ /* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
+ if ((fd < 0) || (fd > MAX_DESCRIPTORS))
+ return;
+
issl_session* session = &sessions[fd];
session->fd = fd;
virtual void OnRawSocketConnect(int fd)
{
+ /* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
+ if ((fd < 0) || (fd > MAX_DESCRIPTORS))
+ return;
+
issl_session* session = &sessions[fd];
session->fd = fd;
virtual void OnRawSocketClose(int fd)
{
+ /* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
+ if ((fd < 0) || (fd > MAX_DESCRIPTORS))
+ return;
+
CloseSession(&sessions[fd]);
EventHandler* user = ServerInstance->SE->GetRef(fd);
virtual int OnRawSocketRead(int fd, char* buffer, unsigned int count, int &readresult)
{
+ /* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
+ if ((fd < 0) || (fd > MAX_DESCRIPTORS))
+ return 0;
+
issl_session* session = &sessions[fd];
if (!session->sess)
{
int ret = DoRead(session);
- ServerInstance->Log(DEBUG, "<***> DoRead count: " + ConvToStr(count));
- ServerInstance->Log(DEBUG, "<***> DoRead ret: " + ConvToStr(ret));
- ServerInstance->Log(DEBUG, "<***> DoRead session->inbufoffset: " + ConvToStr(session->inbufoffset));
-
if (ret > 0)
{
if (count <= session->inbufoffset)
// Zero the offset, as there's nothing there..
session->inbufoffset = 0;
}
-
return 1;
}
- else
- {
- return ret;
- }
+ return ret;
}
}
virtual int OnRawSocketWrite(int fd, const char* buffer, int count)
{
+ /* Are there any possibilities of an out of range fd? Hope not, but lets be paranoid */
+ if ((fd < 0) || (fd > MAX_DESCRIPTORS))
+ return 0;
+
issl_session* session = &sessions[fd];
if (!session->sess)
}
// :kenny.chatspike.net 320 Om Epy|AFK :is a Secure Connection
- virtual void OnWhois(userrec* source, userrec* dest)
+ virtual void OnWhois(User* source, User* dest)
{
if (!clientactive)
return;
}
}
- virtual void OnSyncUserMetaData(userrec* user, Module* proto, void* opaque, const std::string &extname, bool displayable)
+ virtual void OnSyncUserMetaData(User* user, Module* proto, void* opaque, const std::string &extname, bool displayable)
{
// check if the linking module wants to know about OUR metadata
if (extname == "ssl")
// check if its our metadata key, and its associated with a user
if ((target_type == TYPE_USER) && (extname == "ssl"))
{
- userrec* dest = (userrec*)target;
+ User* dest = (User*)target;
// if they dont already have an ssl flag, accept the remote server's
if (!dest->GetExt(extname, dummy))
{
int ret;
if (session->outbound)
- {
ret = SSL_connect(session->sess);
- }
else
ret = SSL_accept(session->sess);
{
// Handshake complete.
// This will do for setting the ssl flag...it could be done earlier if it's needed. But this seems neater.
- userrec* u = ServerInstance->FindDescriptor(session->fd);
+ User* u = ServerInstance->FindDescriptor(session->fd);
if (u)
{
if (!u->GetExt("ssl", dummy))
}
else if (ret == 0)
{
- int ssl_err = SSL_get_error(session->sess, ret);
- char buf[1024];
- ERR_print_errors_fp(stderr);
- ServerInstance->Log(DEBUG,"Handshake fail 2: %d: %s", ssl_err, ERR_error_string(ssl_err,buf));
CloseSession(session);
return true;
}
return true;
}
- virtual void OnPostConnect(userrec* user)
+ virtual void OnPostConnect(User* user)
{
// This occurs AFTER OnUserConnect so we can be sure the
- // protocol module has propogated the NICK message.
+ // protocol module has propagated the NICK message.
if ((user->GetExt("ssl", dummy)) && (IS_LOCAL(user)))
{
// Tell whatever protocol module we're using that we need to inform other servers of this metadata NOW.
//OnRawSocketWrite(session->fd, NULL, 0);
EventHandler* eh = ServerInstance->FindDescriptor(session->fd);
if (eh)
+ {
ServerInstance->SE->WantWrite(eh);
+ }
}
- virtual void OnBufferFlushed(userrec* user)
+ virtual void OnBufferFlushed(User* user)
{
if (user->GetExt("ssl"))
{
return 0;
}
-MODULE_INIT(ModuleSSLOpenSSL);
+MODULE_INIT(ModuleSSLOpenSSL)