← Back to branch summary

~ubuntu-branches/ubuntu/wily/unrar-nonfree/wily-proposed

« back to all changes in this revision

Viewing changes to dll.cpp

  • Committer: Package Import Robot
  • Author(s): Nick Andrik
  • Date: 2013-01-21 23:07:40 UTC
  • mto: This revision was merged to the branch mainline in revision 19.
  • Revision ID: package-import@ubuntu.com-20130121230740-72rp8g92rch565c6
Tags: upstream-4.2.4
Import upstream version 4.2.4

Show diffs side-by-side

added added

removed removed

Lines of Context:
dll.cpp
1
1
#include "rar.hpp"
2
2
#include "dll.hpp"
3
3
 
4
 
static int RarErrorToDll(int ErrCode);
 
4
static int RarErrorToDll(RAR_EXIT ErrCode);
5
5
 
6
6
struct DataSet
7
7
{
33
33
 
34
34
HANDLE PASCAL RAROpenArchiveEx(struct RAROpenArchiveDataEx *r)
35
35
{
 
36
  DataSet *Data=NULL;
36
37
  try
37
38
  {
38
39
    r->OpenResult=0;
39
 
    DataSet *Data=new DataSet;
 
40
    Data=new DataSet;
40
41
    Data->Cmd.DllError=0;
41
42
    Data->OpenMode=r->OpenMode;
42
43
    Data->Cmd.FileArgs->AddString("*");
55
56
    Data->Cmd.Callback=r->Callback;
56
57
    Data->Cmd.UserData=r->UserData;
57
58
 
58
 
    if (!Data->Arc.Open(r->ArcName,r->ArcNameW))
 
59
    if (!Data->Arc.Open(r->ArcName,r->ArcNameW,0))
59
60
    {
60
61
      r->OpenResult=ERAR_EOPEN;
61
62
      delete Data;
86
87
    Data->Extract.ExtractArchiveInit(&Data->Cmd,Data->Arc);
87
88
    return((HANDLE)Data);
88
89
  }
89
 
  catch (int ErrCode)
 
90
  catch (RAR_EXIT ErrCode)
90
91
  {
91
 
    r->OpenResult=RarErrorToDll(ErrCode);
 
92
    if (Data!=NULL && Data->Cmd.DllError!=0)
 
93
      r->OpenResult=Data->Cmd.DllError;
 
94
    else
 
95
      r->OpenResult=RarErrorToDll(ErrCode);
 
96
    if (Data != NULL)
 
97
      delete Data;
92
98
    return(NULL);
93
99
  }
 
100
  catch (std::bad_alloc) // Catch 'new' exception.
 
101
  {
 
102
    r->OpenResult=ERAR_NO_MEMORY;
 
103
    if (Data != NULL)
 
104
      delete Data;
 
105
  }
94
106
}
95
107
 
96
108
 
105
117
 
106
118
int PASCAL RARReadHeader(HANDLE hArcData,struct RARHeaderData *D)
107
119
{
108
 
  DataSet *Data=(DataSet *)hArcData;
109
 
  try
110
 
  {
111
 
    if ((Data->HeaderSize=(int)Data->Arc.SearchBlock(FILE_HEAD))<=0)
112
 
    {
113
 
      if (Data->Arc.Volume && Data->Arc.GetHeaderType()==ENDARC_HEAD &&
114
 
          (Data->Arc.EndArcHead.Flags & EARC_NEXT_VOLUME))
115
 
        if (MergeArchive(Data->Arc,NULL,false,'L'))
116
 
        {
117
 
          Data->Extract.SignatureFound=false;
118
 
          Data->Arc.Seek(Data->Arc.CurBlockPos,SEEK_SET);
119
 
          return(RARReadHeader(hArcData,D));
120
 
        }
121
 
        else
122
 
          return(ERAR_EOPEN);
123
 
      return(Data->Arc.BrokenFileHeader ? ERAR_BAD_DATA:ERAR_END_ARCHIVE);
124
 
    }
125
 
    if (Data->OpenMode==RAR_OM_LIST && (Data->Arc.NewLhd.Flags & LHD_SPLIT_BEFORE))
126
 
    {
127
 
      int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
128
 
      if (Code==0)
129
 
        return(RARReadHeader(hArcData,D));
130
 
      else
131
 
        return(Code);
132
 
    }
133
 
    strncpyz(D->ArcName,Data->Arc.FileName,ASIZE(D->ArcName));
134
 
    strncpyz(D->FileName,Data->Arc.NewLhd.FileName,ASIZE(D->FileName));
135
 
    D->Flags=Data->Arc.NewLhd.Flags;
136
 
    D->PackSize=Data->Arc.NewLhd.PackSize;
137
 
    D->UnpSize=Data->Arc.NewLhd.UnpSize;
138
 
    D->HostOS=Data->Arc.NewLhd.HostOS;
139
 
    D->FileCRC=Data->Arc.NewLhd.FileCRC;
140
 
    D->FileTime=Data->Arc.NewLhd.FileTime;
141
 
    D->UnpVer=Data->Arc.NewLhd.UnpVer;
142
 
    D->Method=Data->Arc.NewLhd.Method;
143
 
    D->FileAttr=Data->Arc.NewLhd.FileAttr;
144
 
    D->CmtSize=0;
145
 
    D->CmtState=0;
146
 
  }
147
 
  catch (int ErrCode)
148
 
  {
149
 
    return(RarErrorToDll(ErrCode));
150
 
  }
151
 
  return(0);
 
120
  struct RARHeaderDataEx X;
 
121
  memset(&X,0,sizeof(X));
 
122
 
 
123
  int Code=RARReadHeaderEx(hArcData,&X);
 
124
 
 
125
  strncpyz(D->ArcName,X.ArcName,ASIZE(D->ArcName));
 
126
  strncpyz(D->FileName,X.FileName,ASIZE(D->FileName));
 
127
  D->Flags=X.Flags;
 
128
  D->PackSize=X.PackSize;
 
129
  D->UnpSize=X.UnpSize;
 
130
  D->HostOS=X.HostOS;
 
131
  D->FileCRC=X.FileCRC;
 
132
  D->FileTime=X.FileTime;
 
133
  D->UnpVer=X.UnpVer;
 
134
  D->Method=X.Method;
 
135
  D->FileAttr=X.FileAttr;
 
136
  D->CmtSize=0;
 
137
  D->CmtState=0;
 
138
 
 
139
  return Code;
152
140
}
153
141
 
154
142
 
171
159
          return(ERAR_EOPEN);
172
160
      return(Data->Arc.BrokenFileHeader ? ERAR_BAD_DATA:ERAR_END_ARCHIVE);
173
161
    }
174
 
    if (Data->OpenMode==RAR_OM_LIST && (Data->Arc.NewLhd.Flags & LHD_SPLIT_BEFORE))
 
162
    if (Data->OpenMode==RAR_OM_LIST && (Data->Arc.NewLhd.Flags & LHD_SPLIT_BEFORE)!=0)
175
163
    {
176
164
      int Code=RARProcessFile(hArcData,RAR_SKIP,NULL,NULL);
177
165
      if (Code==0)
213
201
    D->CmtSize=0;
214
202
    D->CmtState=0;
215
203
  }
216
 
  catch (int ErrCode)
 
204
  catch (RAR_EXIT ErrCode)
217
205
  {
218
 
    return(RarErrorToDll(ErrCode));
 
206
    return(Data->Cmd.DllError!=0 ? Data->Cmd.DllError:RarErrorToDll(ErrCode));
219
207
  }
220
208
  return(0);
221
209
}
287
275
      bool Repeat=false;
288
276
      Data->Extract.ExtractCurrentFile(&Data->Cmd,Data->Arc,Data->HeaderSize,Repeat);
289
277
 
 
278
      // Now we process extra file information if any.
 
279
      //
290
280
      // Archive can be closed if we process volumes, next volume is missing
291
281
      // and current one is already removed or deleted. So we need to check
292
282
      // if archive is still open to avoid calling file operations on
301
291
      Data->Arc.Seek(Data->Arc.CurBlockPos,SEEK_SET);
302
292
    }
303
293
  }
304
 
  catch (int ErrCode)
 
294
  catch (RAR_EXIT ErrCode)
305
295
  {
306
 
    return(RarErrorToDll(ErrCode));
 
296
    return(Data->Cmd.DllError!=0 ? Data->Cmd.DllError:RarErrorToDll(ErrCode));
307
297
  }
308
298
  return(Data->Cmd.DllError);
309
299
}
347
337
void PASCAL RARSetPassword(HANDLE hArcData,char *Password)
348
338
{
349
339
  DataSet *Data=(DataSet *)hArcData;
350
 
  GetWideName(Password,NULL,Data->Cmd.Password,ASIZE(Data->Cmd.Password));
 
340
  wchar PasswordW[MAXPASSWORD];
 
341
  GetWideName(Password,NULL,PasswordW,ASIZE(PasswordW));
 
342
  Data->Cmd.Password.Set(PasswordW);
 
343
  cleandata(PasswordW,sizeof(PasswordW));
351
344
}
352
345
#endif
353
346
 
358
351
}
359
352
 
360
353
 
361
 
static int RarErrorToDll(int ErrCode)
 
354
static int RarErrorToDll(RAR_EXIT ErrCode)
362
355
{
363
356
  switch(ErrCode)
364
357
  {
365
 
    case FATAL_ERROR:
 
358
    case RARX_FATAL:
366
359
      return(ERAR_EREAD);
367
 
    case CRC_ERROR:
 
360
    case RARX_CRC:
368
361
      return(ERAR_BAD_DATA);
369
 
    case WRITE_ERROR:
 
362
    case RARX_WRITE:
370
363
      return(ERAR_EWRITE);
371
 
    case OPEN_ERROR:
 
364
    case RARX_OPEN:
372
365
      return(ERAR_EOPEN);
373
 
    case CREATE_ERROR:
 
366
    case RARX_CREATE:
374
367
      return(ERAR_ECREATE);
375
 
    case MEMORY_ERROR:
 
368
    case RARX_MEMORY:
376
369
      return(ERAR_NO_MEMORY);
377
 
    case SUCCESS:
 
370
    case RARX_SUCCESS:
378
371
      return(0);
379
372
    default:
380
373
      return(ERAR_UNKNOWN);