From 271cf1987ef0dc4d6561d14e0ba89c17bb125903 Mon Sep 17 00:00:00 2001 From: George Hazan Date: Sun, 10 Feb 2013 19:26:03 +0000 Subject: NotifyAnything plugin git-svn-id: http://svn.miranda-ng.org/main/trunk@3539 1316c22d-e87f-b044-9b9b-93d7a3e3ba9c --- plugins/NotifyAnything/src/main.cpp | 1057 +++++++++++++++++++++++++++++++++++ 1 file changed, 1057 insertions(+) create mode 100644 plugins/NotifyAnything/src/main.cpp (limited to 'plugins/NotifyAnything/src/main.cpp') diff --git a/plugins/NotifyAnything/src/main.cpp b/plugins/NotifyAnything/src/main.cpp new file mode 100644 index 0000000000..7ef581fb24 --- /dev/null +++ b/plugins/NotifyAnything/src/main.cpp @@ -0,0 +1,1057 @@ +#include "common.h" + +#define EnterCS(cs) EnterCriticalSection(cs) +#define LeaveCS(cs) LeaveCriticalSection(cs) + +//--------------------------- +//---Internal Hooks +//---(Workaround till CallServiceSync is available) + +/* +Stolen from NewEventNotify: +The idea for this is taken from "NewStatusNotify" by Hrk, thx *g* +This is needed to send a message with safe multithrading. +We'll create a private hook and we'll call it via NotifyEventHooks, which brings execution +back to the main thread. +*/ + +void cslog(const char *what, const char *file, int line) +{ + if (IsLogService){ + std::string LogString; + char buf[10]; + LogString = what; + LogString += ": "; + LogString += file; + LogString += ":"; + LogString += itoa(line, buf, 10); + logservice_log(LOG_ID, NULL, (TCHAR *) LogString.c_str()); + } + else { + if (g_settings.log_to_file) { + time_t t_; + time(&t_); + tm *t = localtime(&t_); + //FILE *f = fopen("na.log", "a"); + FILE *f = fopen(g_settings.log_filename.c_str(), "a"); + if (f) { + //fprintf(f, "%s: %s:%i\n", what, file, line); + fprintf(f, "[%04i-%02i-%02i %02i:%02i:%02i cs] %s: %s:%i\n", + int(t->tm_year+1900), int(t->tm_mon), int(t->tm_mday), + int(t->tm_hour), int(t->tm_min), int(t->tm_sec), what, file, line); + fclose(f); + } + } + } +} + +void EnterCSHelper(CRITICAL_SECTION *cs, const char *file, int line) +{ + cslog(">enter", file, line); + EnterCriticalSection(cs); + cslog("leave", file, line); + LeaveCriticalSection(cs); + cslog(" popups_t; +typedef std::set anon_popups_t; +popups_t g_popups; +anon_popups_t g_anon_popups; +CRITICAL_SECTION g_popups_cs; + +std::string strip(std::string str) +{ + while (!str.empty() && isspace(str[0])) + str.erase(0, 1); + while (!str.empty() && isspace(*(str.end()-1))) + str.erase(str.size()-1); + return str; +} + +void dbg_msg(std::string str, int type) +{ + str = strip(str); + + if (g_settings.debug_messages) + CallServiceSync(MS_POPUP_SHOWMESSAGE, (WPARAM) const_cast(str.c_str()), (LPARAM) type); + + if (IsLogService){ + logservice_log(LOG_ID, NULL, (TCHAR *) str.c_str()); + } + else { + if (g_settings.log_to_file) { + time_t t_; + time(&t_); + tm *t = localtime(&t_); + FILE *f = fopen(g_settings.log_filename.c_str(), "a"); + if (f) { + fprintf(f, "[%04i-%02i-%02i %02i:%02i:%02i dbg_msg] %s\n", + int(t->tm_year+1900), int(t->tm_mon), int(t->tm_mday), + int(t->tm_hour), int(t->tm_min), int(t->tm_sec), str.c_str()); + fclose(f); + } + } + } +} + +void showLastError() +{ + int err = GetLastError(); + + LPVOID lpMsgBuf; + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER|FORMAT_MESSAGE_FROM_SYSTEM|FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, err, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPTSTR) &lpMsgBuf, 0, NULL); + + dbg_msg((char *) lpMsgBuf, SM_WARNING); + + LocalFree(lpMsgBuf); +} + +struct enum_icons_t { + int nr; + LPCTSTR name; + bool found; +}; + +BOOL CALLBACK enum_icons_func(HMODULE, LPCTSTR, LPTSTR name, LONG_PTR data) +{ + enum_icons_t *info = (enum_icons_t *) data; + if (!--info->nr) { + info->found = true; + info->name = name; + return FALSE; + } + return TRUE; +} + +void registerSound(const std::string &name) +{ + static std::set sset; + + if (sset.find(name) != sset.end()) + return; + sset.insert(name); + + std::string id = "NotifyAnything_" + name; + std::string desc = "NotifyAnything: " + name; + std::string file = name + ".wav"; + SkinAddNewSound(id.c_str(), Translate(desc.c_str()), file.c_str()); +} + +HICON getIcon(const std::string &name) +{ + static std::map icons; + static HICON deficon; + static bool init; + if (!init) { + init = true; + + // windows icons + icons["exclamation"] = icons["warning"] = LoadIcon(NULL, IDI_WARNING); + deficon = icons["information"] = icons["asterisk"] = LoadIcon(NULL, IDI_ASTERISK); + icons["hand"] = icons["error"] = LoadIcon(NULL, IDI_ERROR); + icons["question"] = LoadIcon(NULL, IDI_QUESTION); + icons["winlogo"] = LoadIcon(NULL, IDI_WINLOGO); + + // miranda icons + icons["online"] = LoadSkinnedIcon(SKINICON_STATUS_ONLINE); + icons["offline"] = LoadSkinnedIcon(SKINICON_STATUS_OFFLINE); + icons["away"] = LoadSkinnedIcon(SKINICON_STATUS_AWAY); + icons["na"] = LoadSkinnedIcon(SKINICON_STATUS_NA); + icons["occupied"] = LoadSkinnedIcon(SKINICON_STATUS_OCCUPIED); + icons["dnd"] = LoadSkinnedIcon(SKINICON_STATUS_DND); + icons["free4chat"] = LoadSkinnedIcon(SKINICON_STATUS_FREE4CHAT); + icons["invisible"] = LoadSkinnedIcon(SKINICON_STATUS_INVISIBLE); + icons["onthephone"] = LoadSkinnedIcon(SKINICON_STATUS_ONTHEPHONE); + icons["outtolunch"] = LoadSkinnedIcon(SKINICON_STATUS_OUTTOLUNCH); + + icons["message"] = LoadSkinnedIcon(SKINICON_EVENT_MESSAGE); + icons["url"] = LoadSkinnedIcon(SKINICON_EVENT_URL); + icons["file"] = LoadSkinnedIcon(SKINICON_EVENT_FILE); + } + + std::map::iterator i = icons.find(name); + if (i != icons.end()) + return i->second; + + size_t p = name.rfind(','); + if (p == name.npos) { + // try to load icon file + HANDLE h = LoadImageA(NULL, name.c_str(), IMAGE_ICON, 16, 16, LR_LOADFROMFILE); + if (h != NULL) + return icons[name] = (HICON) h; + + showLastError(); + return deficon; + } + + std::tstring file((TCHAR*)_A2T(name.c_str()), 0, p); + + std::tstring rname(file.c_str(), p+1); + if (rname.empty()) { + dbg_msg(Translate("No resource name given."), SM_WARNING); + return deficon; + } + + HMODULE module = LoadLibraryEx(file.c_str(), NULL, LOAD_LIBRARY_AS_DATAFILE); + if (!module) { + showLastError(); + return deficon; + } + + LPCTSTR resname = rname.c_str(); + if (isdigit(rname[0])) { + enum_icons_t info; + info.found = false; + info.nr = _ttoi(rname.c_str()); + if (info.nr <= 0) { + dbg_msg(Translate("Icon indices start at 1."), SM_WARNING); + return deficon; + } + + BOOL ok = EnumResourceNames(module, RT_GROUP_ICON, enum_icons_func, (LONG_PTR) &info); + if (!info.found) { + if (!ok) { + if (GetLastError()) { + showLastError(); + return deficon; + } + } + dbg_msg(Translate("Could not find the requested icon."), SM_WARNING); + return deficon; + } + resname = info.name; + } + + HICON icon = (HICON) LoadImage(module, resname, IMAGE_ICON, 16, 16, 0); + FreeLibrary(module); + + if (!icon) { + showLastError(); + return deficon; + } + + return icons[name] = (HICON) icon; +} + +bool getNext(std::string &out, std::string &in, char sep) +{ + while (!in.empty() && in[0] == ' ') + in.erase(0, 1); + + out.erase(); + + while (!in.empty()) { + if (in[0] == sep) { + in.erase(0,1); + return true; + } + if (in[0] == '\"') { + in.erase(0,1); + size_t p = in.find('\"'); + if (p == in.npos) + throw "Unterminated quote: \"" + in; + out += '"'; + out.append(in, 0, p); + out += '"'; + in.erase(0, p+1); + return true; + } + if (!in.compare(0, 3, "<[[")) { + in.erase(0, 3); + size_t p = in.find("]]>"); + if (p == in.npos) + throw "Unterminated \"<[[\": <[[" + in; + out.append(in, 0, p); + in.erase(0, p+3); + return true; + } + + out += in[0]; + in.erase(0,1); + return true; + } + return false; +} + +std::string unquote(std::string str) +{ + size_t p; + while ((p = str.find('\"')) != str.npos) + str.erase(p, 1); + return str; +} + +void getAll(std::vector &out, std::string &in, char sep, bool unquote_) +{ + std::string arg; + while (getNext(arg, in, sep)) + if (!arg.empty()) { + if (unquote_) + arg = unquote(arg); + out.push_back(arg); + } +} + +const char *decode_se_arg(std::string &str) +{ + return (str.empty()) ? 0 : str.c_str(); +} + +void processSingleAction(const std::string &what, bool &closeflag) +{ + if (!what.compare(0, 7, "system:")) { + if (!g_settings.allow_execute) { + dbg_msg(Translate("Application launching is disabled."), SM_WARNING); + return; + } + + std::string argstr(what, 7); + + if (system(argstr.c_str()) == -1) + dbg_msg("Failed to execute: " + argstr, SM_WARNING); + } + else if (!what.compare(0, 4, "cmd:")) { + if (!g_settings.allow_execute) { + dbg_msg(Translate("Application launching is disabled."), SM_WARNING); + return; + } + + std::string argstr(what, 4); + std::vector args; + + getAll(args, argstr, ' ', true); + + if (args.empty()) + throw "Insufficient arguments: " + what; + + std::vector cargs; + for (std::vector::iterator i=args.begin(), e=args.end(); i!=e; ++i) + cargs.push_back(i->c_str()); + cargs.push_back(0); + + if (_spawnvp(_P_DETACH, cargs[0], &cargs[0]) == -1) + dbg_msg("Failed to execute: " + what.substr(4), SM_WARNING); + + } + else if (!what.compare(0, 5, "open:")) { + if (!g_settings.allow_execute) { + dbg_msg(Translate("Application launching is disabled."), SM_WARNING); + return; + } + + std::string argstr(what, 5); + + std::string file, args; + if (!getNext(file, argstr, ' ')) + throw "No filename provided: " + what; + file = strip(file); + args = strip(argstr); + + const char *cargs = decode_se_arg(args); + + if ((int) ShellExecuteA(0, "open", file.c_str(), cargs, 0, SW_SHOWNORMAL) <= 32) + throw "Failed to open: " + file + " " + args; + + } else if (!what.compare(0, 6, "shell:")) { + if (!g_settings.allow_execute) { + dbg_msg(Translate("Application launching is disabled."), SM_WARNING); + return; + } + + std::string argstr(what, 6); + + std::string verb, file, args, dir; + if (!getNext(verb, argstr, ':')) + throw "No verb provided: " + what; + if (!getNext(file, argstr, ',')) + throw "No filename provided: " + what; + getNext(args, argstr, ','); + getNext(dir, argstr, ','); + verb = unquote(strip(verb)); + file = /*unquote(*/strip(file)/*)*/; + args = strip(args); + dir = /*unquote(*/strip(dir)/*)*/; + + if ((int) ShellExecuteA(0, decode_se_arg(verb), decode_se_arg(file), + decode_se_arg(args), decode_se_arg(dir), SW_SHOWNORMAL) <= 32) + throw "Failed: " + what; + } else if (what == "close") + closeflag = true; + else + throw "Action not recognized: " + what; +} + +void processAction(const std::string &what, bool &closeflag) +{ + try + { + std::string argstr = what; + std::vector actions; + + std::string action; + while (getNext(action, argstr, ';')) + if (!action.empty()) + processSingleAction(action, closeflag); + } + catch (std::string err) { + dbg_msg(err, SM_WARNING); + } +} + +static int CALLBACK PopupDlgProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) +{ + popup_t *pd = 0; + pd = (popup_t *) CallService(MS_POPUP_GETPLUGINDATA, (WPARAM) hWnd, (LPARAM) pd); + if (!pd) + return FALSE; + + switch (message) { + case WM_COMMAND: + { + EnterCS(&g_popups_cs); + std::string left; + if (pd) + left = pd->left; + LeaveCS(&g_popups_cs); + + if (left.empty()) + PUDeletePopUp(hWnd); + else { + bool closeflag = false; + processAction(left, closeflag); + if (closeflag) + PUDeletePopUp(hWnd); + } + } + return TRUE; + + case WM_CONTEXTMENU: + { + EnterCS(&g_popups_cs); + std::string right; + if (pd) + right = pd->right; + LeaveCS(&g_popups_cs); + + if (right.empty()) + PUDeletePopUp(hWnd); + else { + bool closeflag = false; + processAction(right, closeflag); + if (closeflag) + PUDeletePopUp(hWnd); + } + } + return TRUE; + + case UM_INITPOPUP: + EnterCS(&g_popups_cs); + pd->hwnd = hWnd; + LeaveCS(&g_popups_cs); + return TRUE; + + case UM_FREEPLUGINDATA: + EnterCS(&g_popups_cs); + std::string closed; + if (pd) + closed = pd->closed; + + g_popups.erase(pd->id); + g_anon_popups.erase(pd); + delete pd; + LeaveCS(&g_popups_cs); + + if (!closed.empty()) { + bool closeflag = false; + processAction(closed, closeflag); + } + + return TRUE; + } + return DefWindowProc(hWnd, message, wParam, lParam); +} + +int showMessage(const popup_t &msg) +{ + POPUPDATAEX ppd = { 0 }; + strncpy(ppd.lpzText, strip(msg.message).c_str(), MAX_SECONDLINE); + strncpy(ppd.lpzContactName, msg.contact.c_str(), MAX_CONTACTNAME); + ppd.colorBack = msg.background; + ppd.colorText = msg.foreground; + ppd.lchIcon = getIcon(msg.icon); + ppd.PluginWindowProc = (WNDPROC) PopupDlgProc; + ppd.iSeconds = msg.delay; + + EnterCS(&g_popups_cs); + + popup_t *msgp = new popup_t(msg); + + if (!msg.id.empty()) + g_popups[msg.id] = msgp; + g_anon_popups.insert(msgp); + ppd.PluginData = msgp; + + LeaveCS(&g_popups_cs); + + return CallServiceSync(MS_POPUP_ADDPOPUPEX, (WPARAM)&ppd, 0); +} + +void replaceMessage(const popup_t &msg) +{ + EnterCS(&g_popups_cs); + + popups_t::iterator i = g_popups.find(msg.id); + if (i != g_popups.end()) { + if (i->second->hwnd) { + + popup_t &nmsg = *i->second; + + switch (msg.replace) { + case xreplace: + nmsg.message = msg.message; break; + case xappend: + nmsg.message += msg.message; break; + case xprepend: + nmsg.message = msg.message + nmsg.message; break; + default: + break; + } + + if (!msg.left.empty()) + nmsg.left = msg.left; + if (!msg.right.empty()) + nmsg.right = msg.right; + if (!msg.opened.empty()) + nmsg.opened = msg.opened; + if (!msg.closed.empty()) + nmsg.closed = msg.closed; + + LeaveCS(&g_popups_cs); + + CallServiceSync(MS_POPUP_CHANGETEXT, (WPARAM)i->second->hwnd, (LPARAM)strip(i->second->message).c_str()); + return; + } + } + + LeaveCS(&g_popups_cs); +} + +inline int dehex(int c) { + if (c >= '0' && c <= '9') + return c - '0'; + else if (c >= 'a' && c <= 'f') + return c - 'a' + 10; + else if (c >= 'A' && c <= 'F') + return c - 'A' + 10; + else + return 0; +} + +COLORREF parseColor(const std::string &buf, bool &ok) +{ + ok = false; + for (int i=0; i!=buf.size(); ++i) + if (!isxdigit(buf[i])) + return RGB(0,0,0); + if (buf.size() == 6) { + int r = (dehex(buf[0]) << 4) + dehex(buf[1]); + int g = (dehex(buf[2]) << 4) + dehex(buf[3]); + int b = (dehex(buf[4]) << 4) + dehex(buf[5]); + ok = true; + return RGB(r,g,b); + } else if (buf.size() == 3) { + int r = dehex(buf[0])*17; + int g = dehex(buf[1])*17; + int b = dehex(buf[2])*17; + ok = true; + return RGB(r,g,b); + } else + return RGB(0,0,0); +} + +void loadDefaults(popup_t &msg, char ch) +{ + msg.hwnd = NULL; + msg.replace = xno; + msg.delay = 0; + switch (ch) { + case '%': + msg.icon = "message"; + msg.background = RGB(173,206,247); + msg.foreground = RGB(0,0,0); + msg.contact = "Message"; + msg.beep = true; + msg.sound = "Message"; + return; + case '!': + msg.icon = "exclamation"; + msg.background = RGB(191,0,0); + msg.foreground = RGB(255,245,225); + msg.contact = "Error"; + msg.beep = true; + msg.sound = "Error"; + return; + case ' ': + default: + msg.icon = "information"; + msg.background = RGB(255,245,225); + msg.foreground = RGB(0,0,0); + msg.contact = "Notice"; + msg.beep = true; + msg.sound = "Notice"; + return; + } +} + +bool parseSimpleMessage(const std::string &buf, popup_t &msg, char sep) +{ + size_t p = buf.find(sep); + if (p == buf.npos) + msg.message = buf; + else { + msg.contact.assign(buf, 0, p); + msg.message.assign(buf, p+1, buf.npos); + } + return true; +} + +bool parseComplexMessage(const std::string &buf, popup_t &msg, char sep) +{ + const char *p = buf.c_str(); + const char *npos = strchr(p, sep); + bool passok = false; + + while ((p = npos)) { + ++p; + const char *cpos = strchr(p, ':'); + npos = strchr(p, sep); + + const char *wend = cpos; + if (!wend || npos && npos < wend) + wend = npos; + if (!wend) { + dbg_msg(Translate("Unterminated option."), SM_WARNING); + return false; + } + + std::string what(p, wend); + std::string arg; + if (wend == cpos && wend && npos) + arg.assign(cpos+1, npos); + else if (!cpos) + arg.erase(); + else + arg = cpos+1; + + if (!g_settings.password.empty() && !passok) { + if (what == "passwd" && arg == g_settings.password) { + passok = true; + continue; + } else + return false; + } + + if (what == "passwd") + ; + else if (what == "icon") + msg.icon = arg; + else if (what == "msg") { + if (!cpos) { + dbg_msg(Translate("No argument given to msg option."), SM_WARNING); + return false; + } else if (msg.replace != xno && msg.id.empty()) { + dbg_msg(Translate("Id is required for replacement."), SM_WARNING); + return false; + } + msg.message = arg; + return true; + } else if (what == "replace") { + if (arg == "yes") + msg.replace = xreplace; + else if (arg == "append") + msg.replace = xappend; + else if (arg == "prepend") + msg.replace = xprepend; + else if (arg == "no") + msg.replace = xno; + else + dbg_msg(Translate("Invalid argument for replace option: ") + arg, SM_WARNING); + } else if (what == "sound") { + if (arg.empty()) + msg.beep = false; + else { + msg.beep = true; + msg.sound = arg; + registerSound(arg); + } + } else if (what == "left") { + msg.left = arg; + } else if (what == "right") { + msg.right = arg; + } else if (what == "opened") { + msg.opened = arg; + } else if (what == "closed") { + msg.closed = arg; + } else if (what == "delay") { + msg.delay = atoi(arg.c_str()); + } else if (what == "id") { + msg.id = arg; + } else if (what == "bg") { + bool ok; + msg.background = parseColor(arg, ok); + if (!ok) + dbg_msg("Invalid color: " + arg, SM_WARNING); + } else if (what == "fg") { + bool ok; + msg.foreground = parseColor(arg, ok); + if (!ok) + dbg_msg("Invalid color: " + arg, SM_WARNING); + } else if (what == "from") + msg.contact = arg; + else if (what == "sep") { + if (arg.size() == 1) + sep = arg[0]; + else + dbg_msg("Invalid argument for sep option: " + arg, SM_WARNING); + } else if (what == "beep") { + if (arg == "1") + msg.beep = true; + else if (arg == "0") + msg.beep = false; + else + dbg_msg("Invalid argument for beep option: " + arg, SM_WARNING); + } else + dbg_msg("Unknown option: " + what, SM_NOTIFY); + } + return true; +} + +bool parseMessage(const std::string &abuf, popup_t &msg) +{ + if (abuf.empty()) { + dbg_msg(Translate("Empty message ignored."), SM_NOTIFY); + return false; + } + + std::string buf = abuf; + char sep = '#'; + if (buf.size() >= 3 && !isalnum(buf[0]) && buf[0] == buf[1] && buf[1] == buf[2]) { + sep = buf[0]; + buf.erase(0, 3); + } + + if (strchr("*!%", buf[0]) && sep != buf[0]) { + if (buf.size() < 2) return false; + loadDefaults(msg, buf[0]); + buf.erase(0, 1); + } else + loadDefaults(msg, ' '); + + if (buf[0] == sep) + return parseComplexMessage(buf, msg, sep); + else if (g_settings.password.empty()) + return parseSimpleMessage(buf, msg, sep); + else + return false; +} + +void processMessage(std::string buf) +{ + if (IsLogService){ + logservice_log(LOG_ID, NULL, (TCHAR *) buf.c_str()); + } + else { + if (g_settings.log_to_file) { + time_t t_; + time(&t_); + tm *t = localtime(&t_); + FILE *f = fopen(g_settings.log_filename.c_str(), "a"); + if (f) { + bool err = fprintf(f, "[%04i-%02i-%02i %02i:%02i:%02i] %s\n", + int(t->tm_year+1900), int(t->tm_mon+1), int(t->tm_mday), + int(t->tm_hour), int(t->tm_min), int(t->tm_sec), buf.c_str()) < 0; + if (fclose(f) == EOF || err) + dbg_msg(Translate("Failed to write to log file."), SM_WARNING); + } else + dbg_msg(Translate("Failed to open log file."), SM_WARNING); + } + } + + popup_t msg; + if (parseMessage(buf, msg)) { + + if (!msg.opened.empty()) { + bool close = false; + processAction(msg.opened, close); + if (close) + return; + } + + if (msg.replace) { + replaceMessage(msg); + return; + } + + showMessage(msg); + + if (g_settings.sound == g_settings.always + || g_settings.sound == g_settings.request + && msg.beep) + { + if (g_settings.use_pcspeaker) + Beep(650, 50); + else { + std::string sname = "NotifyAnything_" + + msg.sound; + SkinPlaySound(sname.c_str()); + } + } + } +} + +void initWinsock() +{ + EnterCS(&g_wsocklock); + if (g_firstrun) { + // probably not needed, but just in case... + // give PopUp a second to sort itself out + Sleep(1000); + g_firstrun = false; + + WSADATA wsaData; + int err = WSAStartup(MAKEWORD(2, 0), &wsaData); + if (err) + throw "WSAStartup failed"; + } + LeaveCS(&g_wsocklock); +} + +DWORD udptcpThreadFunc(LPVOID useUdp) +{ + try + { + initWinsock(); + + SOCKET sock = socket(AF_INET, useUdp ? SOCK_DGRAM : SOCK_STREAM, 0/*IPPROTO_UDP*/); + if (sock == INVALID_SOCKET) + throw "socket failed"; + + if (useUdp) + g_udp_socket = sock; + else + g_tcp_socket = sock; + + SOCKADDR_IN addr; + ZeroMemory(&addr, sizeof addr); + addr.sin_family = AF_INET; + addr.sin_port = htons(g_settings.port); + if (g_settings.local_only) { + addr.sin_addr.S_un.S_un_b.s_b1 = 127; + addr.sin_addr.S_un.S_un_b.s_b2 = 0; + addr.sin_addr.S_un.S_un_b.s_b3 = 0; + addr.sin_addr.S_un.S_un_b.s_b4 = 1; + } + + if (bind(sock, reinterpret_cast(&addr), sizeof addr)) + throw "bind failed"; + + SOCKADDR_IN from; + char buf[4097]; + + if (useUdp) { + while (!g_exit_threads) { + int fromSize = sizeof from; + int err = recvfrom(sock, buf, sizeof buf - 1, 0, reinterpret_cast(&from), &fromSize); + + if (g_exit_threads) + return 0; + + if (err == SOCKET_ERROR) + throw "socket error"; + + buf[err] = '\0'; + + if (err > 0) + processMessage(buf); + } + } else { + listen(sock, SOMAXCONN); + while (!g_exit_threads) { + int fromSize = sizeof from; + SOCKET msgsock = accept(sock, reinterpret_cast(&from), &fromSize); + + if (g_exit_threads) + return 0; + + if (msgsock == INVALID_SOCKET) + throw "socket error"; + + std::string totalbuf; + int totallen = 0; + while (true) { + int err = recv(msgsock, buf, sizeof buf - 1, 0); + if (err < 0) { + totalbuf.clear(); + break; + } else if (err == 0) + break; + else { + totallen += err; + buf[err] = '\0'; + totalbuf += buf; + } + } + if (!totalbuf.empty()) + processMessage(buf); + } + } + return 0; + } + catch (const char *err) { + std::string t = err; + t += "\nWSAGetLastError: "; + + DWORD ec = WSAGetLastError(); + + char buf[4096]; + strcpy(buf, Translate("N/A: Failed to format error message")); + + DWORD fm = FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, ec, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), buf, 4096, NULL); + + if (!fm) { + t += Translate("N/A: FormatMessage failed, error code was 0x"); + char tbuf[10]; + t += itoa(ec, tbuf, 16); + } else + t += buf; + + MessageBoxA(0, t.c_str(), Translate("Error"), MB_OK); + return 1; + } +} + +void start_threads() +{ + g_exit_threads = false; + DWORD id; + g_udp_thread = CreateThread(NULL, 0, + (LPTHREAD_START_ROUTINE) udptcpThreadFunc, (LPVOID) 1, 0, &id); + g_tcp_thread = CreateThread(NULL, 0, + (LPTHREAD_START_ROUTINE) udptcpThreadFunc, NULL, 0, &id); +} + +void stop_threads() +{ + g_exit_threads = true; + shutdown(g_udp_socket, 2); + shutdown(g_tcp_socket, 2); + closesocket(g_udp_socket); + closesocket(g_tcp_socket); + WaitForSingleObject(g_udp_thread, INFINITE); + WaitForSingleObject(g_tcp_thread, INFINITE); +} + +extern "C" __declspec(dllexport) PLUGININFOEX* MirandaPluginInfoEx(DWORD mirandaVersion) +{ + return &pluginInfo; +} + +int ModulesLoaded(WPARAM wParam, LPARAM lParam) +{ + IsLogService = ServiceExists(MS_LOGSERVICE_REGISTER) != 0; + if (IsLogService) + logservice_register(LOG_ID, LPGENT(LOG_ID), NULL, NULL); + + return 0; +} + +extern "C" int __declspec(dllexport) Load() +{ + g_firstrun = true; + mir_getLP(&pluginInfo); + + char buf[MAX_PATH+1]; + strcpy(buf, "."); + g_mirandaDir = getcwd(buf, MAX_PATH); + + InitializeCriticalSection(&g_popups_cs); + InitializeCriticalSection(&g_wsocklock); + + registerSound("Notice"); + registerSound("Message"); + registerSound("Error"); + + load_settings(); + + HookEvent(ME_OPT_INITIALISE, OptionsInitialize); + HookEvent(ME_SYSTEM_MODULESLOADED, ModulesLoaded); + + start_threads(); + return 0; +} + +extern "C" int __declspec(dllexport) Unload(void) +{ + stop_threads(); + WSACleanup(); + + DeleteCriticalSection(&g_popups_cs); + DeleteCriticalSection(&g_wsocklock); + return 0; +} -- cgit v1.2.3