multiarc/src/MultiArc.cpp

   1 #include "MultiArc.hpp"
   2 #include "marclng.hpp"
   3 #include <string>
   4 #include <unistd.h>
   5
   6 SHAREDSYMBOL int WINAPI _export GetMinFarVersion(void)
   7 {
   8 #define MAKEFARVERSION(major, minor) (((major) << 16) | (minor))
   9         return MAKEFARVERSION(2, 1);
  10 }
  11
  12 SHAREDSYMBOL void WINAPI _export SetStartupInfo(const struct PluginStartupInfo *Info)
  13 {
  14         ::Info = *Info;
  15         FSF = *Info->FSF;
  16         ::Info.FSF = &FSF;
  17
  18         ::Info.FSF->Reserved[0] = (DWORD_PTR)malloc;
  19         ::Info.FSF->Reserved[1] = (DWORD_PTR)free;
  20
  21         if (ArcPlugin == NULL)
  22                 ArcPlugin = new ArcPlugins(Info->ModuleName);
  23
  24         KeyFileReadSection kfh(INI_LOCATION, INI_SECTION);
  25         Opt.HideOutput = kfh.GetInt("HideOutput", 0);
  26         Opt.ProcessShiftF1 = kfh.GetInt("ProcessShiftF1", 1);
  27         Opt.UseLastHistory = kfh.GetInt("UseLastHistory", 0);
  28
  29         // Opt.DeleteExtFile=GetRegKey(HKEY_CURRENT_USER,"","DeleteExtFile",1);
  30         // Opt.AddExtArchive=GetRegKey(HKEY_CURRENT_USER,"","AddExtArchive",0);
  31
  32         // Opt.AutoResetExactArcName=GetRegKey(HKEY_CURRENT_USER,"","AutoResetExactArcName",1);
  33         // Opt.ExactArcName=GetRegKey(HKEY_CURRENT_USER, "", "ExactArcName", 0);
  34         Opt.AdvFlags = kfh.GetInt("AdvFlags", 2);
  35
  36         Opt.DescriptionNames = kfh.GetString("DescriptionNames", "descript.ion,files.bbs");
  37         Opt.ReadDescriptions = kfh.GetInt("ReadDescriptions", 0);
  38         Opt.UpdateDescriptions = kfh.GetInt("UpdateDescriptions", 0);
  39         // Opt.UserBackground=GetRegKey(HKEY_CURRENT_USER,"","Background",0); // $ 06.02.2002 AA
  40         Opt.OldUserBackground = 0;      // $ 02.07.2002 AY
  41         Opt.AllowChangeDir = kfh.GetInt("AllowChangeDir", 0);
  42
  43         kfh.GetChars(Opt.CommandPrefix1, sizeof(Opt.CommandPrefix1), "Prefix1", "ma");
  44
  45 #ifdef _NEW_ARC_SORT_
  46         strcpy(IniFile, Info->ModuleName);
  47         *((int *)(IniFile + strlen(IniFile) - 3)) = 0x696E69;   // :)
  48 #endif
  49         Opt.PriorityClass = 2;                                                                  // default: NORMAL
  50 }
  51
  52 static const char *KnownDocumentTypes[] = {"docx", "docm", "dotx", "dotm",
  53
  54                 "xlsx", "xlsm", "xltx", "xltm", "xlsb", "xlam", "pptx", "pptm", "potx", "potm", "ppam", "ppsx",
  55
  56                 "ppsm", "sldx", "sldm", "thmx",
  57
  58                 "odt", "ods", "odp"};
  59
  60 static bool IsKnownDocumentType(const char *Name)
  61 {
  62         const char *ext = strrchr(Name, '.');
  63         if (ext && ext[1]) {
  64                 ++ext;
  65                 for (const char *known_type : KnownDocumentTypes) {
  66                         if (strcasecmp(ext, known_type) == 0) {
  67                                 return true;
  68                         }
  69                 }
  70         }
  71         return false;
  72 }
  73
  74 SHAREDSYMBOL HANDLE WINAPI _export
  75 OpenFilePlugin(const char *Name, const unsigned char *Data, int DataSize, int OpMode)
  76 {
  77         if (ArcPlugin == NULL)
  78                 return INVALID_HANDLE_VALUE;
  79
  80         // if its a docx&etc then Enter should open document by default instead of sinking into it
  81         // as archive (even while its really archive)
  82         if (OpMode == 0 && Name && IsKnownDocumentType(Name))
  83                 return INVALID_HANDLE_VALUE;
  84
  85         int ArcPluginNumber = -1;
  86         if (Name == NULL) {
  87                 if (!Opt.ProcessShiftF1)
  88                         return INVALID_HANDLE_VALUE;
  89         } else {
  90                 ArcPluginNumber = ArcPlugin->IsArchive(Name, Data, DataSize);
  91                 if (ArcPluginNumber == -1)
  92                         return INVALID_HANDLE_VALUE;
  93         }
  94
  95         try {
  96                 PluginClass *pPlugin = new PluginClass(ArcPluginNumber);
  97                 if (Name != NULL && !pPlugin->PreReadArchive(Name)) {
  98                         delete pPlugin;
  99                         return INVALID_HANDLE_VALUE;
 100                 }
 101                 return (HANDLE)pPlugin;
 102
 103         } catch (std::exception &e) {
 104                 fprintf(stderr, "OpenFilePlugin: %s\n", e.what());
 105                 return INVALID_HANDLE_VALUE;
 106         }
 107 }
 108
 109 std::string MakeFullName(const char *name)
 110 {
 111         if (name[0] == '/')
 112                 return name;
 113
 114         std::string out;
 115         char cd[PATH_MAX];
 116         if (getcwd(cd, sizeof(cd))) {
 117                 if (name[0] == '.' && name[1] == '/') {
 118                         name+= 2;
 119                 }
 120                 out = cd;
 121                 out+= '/';
 122         }
 123
 124         out+= name;
 125         return out;
 126 }
 127
 128 static HANDLE OpenPluginWithCmdLine(const char *CmdLine)
 129 {
 130         const size_t Prefix1Len = strnlen(Opt.CommandPrefix1, ARRAYSIZE(Opt.CommandPrefix1));
 131         if (strncmp(CmdLine, Opt.CommandPrefix1, Prefix1Len) != 0)
 132                 return INVALID_HANDLE_VALUE;
 133
 134         if (CmdLine[Prefix1Len] != ':' || CmdLine[Prefix1Len + 1] == 0)
 135                 return INVALID_HANDLE_VALUE;
 136
 137         std::string filename = MakeFullName(&CmdLine[Prefix1Len + 1]);
 138         if (filename.empty())
 139                 return INVALID_HANDLE_VALUE;
 140
 141         HANDLE h = WINPORT(CreateFile)(StrMB2Wide(filename).c_str(), GENERIC_READ, FILE_SHARE_READ, NULL,
 142                         OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 143         if (h == INVALID_HANDLE_VALUE)
 144                 return INVALID_HANDLE_VALUE;
 145
 146         DWORD datasize = (DWORD)Info.AdvControl(Info.ModuleNumber, ACTL_GETPLUGINMAXREADDATA, (void *)0);
 147         if (!datasize)
 148                 return INVALID_HANDLE_VALUE;
 149
 150         unsigned char *data = (unsigned char *)malloc(datasize);
 151         if (!data)
 152                 return INVALID_HANDLE_VALUE;
 153
 154         if (!WINPORT(ReadFile)(h, data, datasize, &datasize, NULL))
 155                 datasize = 0;
 156
 157         WINPORT(CloseHandle)(h);
 158
 159         h = (datasize == 0)
 160                         ? INVALID_HANDLE_VALUE
 161                         : OpenFilePlugin(filename.c_str(), data, datasize, OPM_COMMANDS);
 162
 163         free(data);
 164
 165         return h;
 166 }
 167
 168 SHAREDSYMBOL HANDLE WINAPI _export OpenPlugin(int OpenFrom, INT_PTR Item)
 169 {
 170         if (ArcPlugin == NULL)
 171                 return INVALID_HANDLE_VALUE;
 172
 173         if (OpenFrom == OPEN_COMMANDLINE)
 174                 return OpenPluginWithCmdLine((const char *)Item);
 175
 176         return INVALID_HANDLE_VALUE;
 177 }
 178
 179 SHAREDSYMBOL void WINAPI _export ClosePlugin(HANDLE hPlugin)
 180 {
 181         delete (PluginClass *)hPlugin;
 182 }
 183
 184 SHAREDSYMBOL int WINAPI _export
 185 GetFindData(HANDLE hPlugin, struct PluginPanelItem **pPanelItem, int *pItemsNumber, int OpMode)
 186 {
 187         PluginClass *Plugin = (PluginClass *)hPlugin;
 188         return Plugin->GetFindData(pPanelItem, pItemsNumber, OpMode);
 189 }
 190
 191 SHAREDSYMBOL void WINAPI _export
 192 FreeFindData(HANDLE hPlugin, struct PluginPanelItem *PanelItem, int ItemsNumber)
 193 {
 194         PluginClass *Plugin = (PluginClass *)hPlugin;
 195         Plugin->FreeFindData(PanelItem, ItemsNumber);
 196 }
 197
 198 SHAREDSYMBOL int WINAPI _export SetDirectory(HANDLE hPlugin, const char *Dir, int OpMode)
 199 {
 200         PluginClass *Plugin = (PluginClass *)hPlugin;
 201         return Plugin->SetDirectory(Dir, OpMode);
 202 }
 203
 204 SHAREDSYMBOL int WINAPI _export
 205 DeleteFiles(HANDLE hPlugin, struct PluginPanelItem *PanelItem, int ItemsNumber, int OpMode)
 206 {
 207         PluginClass *Plugin = (PluginClass *)hPlugin;
 208         return Plugin->DeleteFiles(PanelItem, ItemsNumber, OpMode);
 209 }
 210
 211 SHAREDSYMBOL int WINAPI _export GetFiles(HANDLE hPlugin, struct PluginPanelItem *PanelItem, int ItemsNumber,
 212                 int Move, char *DestPath, int OpMode)
 213 {
 214         PluginClass *Plugin = (PluginClass *)hPlugin;
 215         return Plugin->GetFiles(PanelItem, ItemsNumber, Move, DestPath, OpMode);
 216 }
 217
 218 SHAREDSYMBOL int WINAPI _export
 219 PutFiles(HANDLE hPlugin, struct PluginPanelItem *PanelItem, int ItemsNumber, int Move, int OpMode)
 220 {
 221         PluginClass *Plugin = (PluginClass *)hPlugin;
 222         return Plugin->PutFiles(PanelItem, ItemsNumber, Move, OpMode);
 223 }
 224
 225 SHAREDSYMBOL void WINAPI _export ExitFAR()
 226 {
 227         delete ArcPlugin;
 228         ArcPlugin = NULL;
 229 }
 230
 231 SHAREDSYMBOL void WINAPI _export GetPluginInfo(struct PluginInfo *Info)
 232 {
 233         Info->StructSize = sizeof(*Info);
 234         Info->Flags = PF_FULLCMDLINE;
 235         static const char *PluginCfgStrings[1];
 236         PluginCfgStrings[0] = (char *)GetMsg(MCfgLine0);
 237         Info->PluginConfigStrings = PluginCfgStrings;
 238         Info->PluginConfigStringsNumber = ARRAYSIZE(PluginCfgStrings);
 239         static char CommandPrefix[sizeof(Opt.CommandPrefix1)];
 240         ArrayCpyZ(CommandPrefix, Opt.CommandPrefix1);
 241         Info->CommandPrefix = CommandPrefix;
 242 }
 243
 244 SHAREDSYMBOL void WINAPI _export GetOpenPluginInfo(HANDLE hPlugin, struct OpenPluginInfo *Info)
 245 {
 246         PluginClass *Plugin = (PluginClass *)hPlugin;
 247         Plugin->GetOpenPluginInfo(Info);
 248 }
 249
 250 SHAREDSYMBOL int WINAPI _export
 251 ProcessHostFile(HANDLE hPlugin, struct PluginPanelItem *PanelItem, int ItemsNumber, int OpMode)
 252 {
 253         PluginClass *Plugin = (PluginClass *)hPlugin;
 254         return Plugin->ProcessHostFile(PanelItem, ItemsNumber, OpMode);
 255 }
 256
 257 SHAREDSYMBOL int WINAPI _export ProcessKey(HANDLE hPlugin, int Key, unsigned int ControlState)
 258 {
 259         PluginClass *Plugin = (PluginClass *)hPlugin;
 260         return Plugin->ProcessKey(Key, ControlState);
 261 }
 262
 263 SHAREDSYMBOL int WINAPI _export Configure(int ItemNumber)
 264 {
 265         struct FarMenuItem MenuItems[2];
 266         ZeroFill(MenuItems);
 267         ArrayCpyZ(MenuItems[0].Text, GetMsg(MCfgLine1));
 268         ArrayCpyZ(MenuItems[1].Text, GetMsg(MCfgLine2));
 269         MenuItems[0].Selected = TRUE;
 270
 271         do {
 272                 ItemNumber = Info.Menu(Info.ModuleNumber, -1, -1, 0, FMENU_WRAPMODE, GetMsg(MCfgLine0), NULL,
 273                                 "Config", NULL, NULL, MenuItems, ARRAYSIZE(MenuItems));
 274                 switch (ItemNumber) {
 275                         case -1:
 276                                 return FALSE;
 277                         case 0:
 278                                 ConfigGeneral();
 279                                 break;
 280                         case 1: {
 281                                 char ArcFormat[100];
 282                                 *ArcFormat = 0;
 283                                 while (PluginClass::SelectFormat(ArcFormat))
 284                                         ;       // ConfigCommands(ArcFormat);
 285                                 break;
 286                         }
 287                 }
 288                 MenuItems[0].Selected = FALSE;
 289                 MenuItems[1].Selected = FALSE;
 290                 MenuItems[ItemNumber].Selected = TRUE;
 291         } while (1);
 292
 293         // return FALSE;
 294 }
 295
 296 std::string gMultiArcPluginPath;
 297
 298 SHAREDSYMBOL void PluginModuleOpen(const char *path)
 299 {
 300         gMultiArcPluginPath = path;
 301 }