← Back to branch summary

~ubuntu-branches/ubuntu/dapper/pantomime/dapper

« back to all changes in this revision

Viewing changes to Source/LocalMessage.m

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2004-11-20 00:25:28 UTC
  • mfrom: (2.1.1 warty)
  • Revision ID: james.westby@ubuntu.com-20041120002528-igjuwyao6gubpig1
Tags: 1.1.2-3
Build depend / depend on libgnustep-base-1.10-dev.

Show diffs side-by-side

added added

removed removed

Lines of Context:
Source/LocalMessage.m
1
1
/*
2
2
**  LocalMessage.m
3
3
**
4
 
**  Copyright (c) 2001, 2002
 
4
**  Copyright (c) 2001, 2002, 2003
5
5
**
6
6
**  Author: Ludovic Marcotte <ludovic@Sophos.ca>
7
7
**
20
20
**  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21
21
*/
22
22
 
23
 
#import <Pantomime/LocalMessage.h>
24
 
 
25
 
#import <Pantomime/Constants.h>
26
 
#import <Pantomime/LocalFolder.h>
27
 
#import <Pantomime/NSDataExtensions.h>
28
 
 
29
 
#import <string.h>
30
 
 
 
23
#include <Pantomime/LocalMessage.h>
 
24
 
 
25
#include <Pantomime/Constants.h>
 
26
#include <Pantomime/LocalFolder.h>
 
27
#include <Pantomime/LocalStore.h>
 
28
#include <Pantomime/NSData+Extensions.h>
 
29
 
 
30
#include <Foundation/NSDebug.h>
 
31
#include <Foundation/NSException.h>
 
32
#include <Foundation/NSValue.h>
 
33
 
 
34
#include <string.h>
 
35
 
 
36
static int currentLocalMessageVersion = 1;
 
37
 
 
38
//
 
39
//
 
40
//
31
41
@implementation LocalMessage 
32
42
 
 
43
- (id) init
 
44
{
 
45
  self = [super init];
 
46
 
 
47
  [LocalMessage setVersion: currentLocalMessageVersion];
 
48
 
 
49
  return self;
 
50
}
 
51
 
 
52
 
33
53
//
34
54
// NSCoding protocol
35
55
//
36
56
- (void) encodeWithCoder: (NSCoder *) theCoder
37
57
{
38
 
  //NSLog(@"Encoding LocalMessage...");
39
58
  [super encodeWithCoder: theCoder];
40
 
  
 
59
 
 
60
  [LocalMessage setVersion: currentLocalMessageVersion];
 
61
        
41
62
  [theCoder encodeObject: [NSNumber numberWithLong: [self filePosition]]];
42
63
  [theCoder encodeObject: [NSNumber numberWithLong: [self bodyFilePosition]]];
 
64
 
 
65
  // Store the name of the file; we need it for local.
 
66
  [theCoder encodeObject: mailFilename];
 
67
 
 
68
  // Store the message type; useful to have.
 
69
  [theCoder encodeObject: [NSNumber numberWithInt: [self messageType]]];
43
70
}
44
71
 
 
72
 
 
73
//
 
74
//
 
75
//
45
76
- (id) initWithCoder: (NSCoder *) theCoder
46
77
{ 
 
78
  int version;
 
79
 
47
80
  self = [super initWithCoder: theCoder];
48
81
  
49
 
  //NSLog(@"Decoding LocalMessage...");
50
 
 
51
82
  [self setFilePosition: [[theCoder decodeObject] longValue]];
52
83
  [self setBodyFilePosition: [[theCoder decodeObject] longValue]];
53
 
  
 
84
 
 
85
  version = [theCoder versionForClassName: @"LocalMessage"];
 
86
 
 
87
  if ( version == 1 )
 
88
    {
 
89
      // Retrieve the mail file name which we need for local storage.
 
90
      [self setMailFilename: [theCoder decodeObject]];
 
91
      
 
92
      // Retrieve the message type
 
93
      [self setMessageType: [[theCoder decodeObject] intValue]];
 
94
    }
 
95
  else
 
96
    {
 
97
      [NSException raise: NSInternalInconsistencyException
 
98
                   format: @"LocalMessage cache error."];
 
99
    }
 
100
 
54
101
  return self;
55
102
}
56
103
 
 
104
 
57
105
//
58
106
// access / mutation methods
59
107
//
67
115
  filePosition = theFilePosition;
68
116
}
69
117
 
 
118
 
 
119
//
 
120
//
 
121
//
70
122
- (long) bodyFilePosition
71
123
{
72
124
  return bodyFilePosition;
73
125
}
74
126
 
 
127
 
75
128
- (void) setBodyFilePosition: (long) theBodyFilePosition
76
129
{
77
130
  bodyFilePosition = theBodyFilePosition;
78
131
}
79
132
 
 
133
 
 
134
//
 
135
//
 
136
//
 
137
- (int) messageType
 
138
{
 
139
  return messageType;
 
140
}
 
141
 
 
142
 
 
143
- (void) setMessageType: (int) theType
 
144
{
 
145
  messageType = theType;
 
146
}
 
147
 
 
148
 
 
149
//
 
150
//
 
151
//
 
152
- (NSString *) mailFilename
 
153
{
 
154
  return (mailFilename);
 
155
}
 
156
 
 
157
 
 
158
- (void) setMailFilename: (NSString *) theFilename
 
159
{       
 
160
  if ( theFilename )
 
161
    {
 
162
      RETAIN(theFilename);
 
163
      RELEASE(mailFilename);
 
164
      mailFilename = theFilename;
 
165
    }
 
166
  else
 
167
    {
 
168
      DESTROY(mailFilename);
 
169
    }
 
170
}
 
171
 
 
172
 
 
173
//
 
174
//
 
175
//
 
176
- (void) dealloc
 
177
{
 
178
  TEST_RELEASE(mailFilename);
 
179
  
 
180
  [super dealloc];
 
181
}
 
182
 
 
183
 
 
184
//
 
185
//
 
186
//
80
187
- (NSData *) rawSource
81
188
{
82
189
  NSMutableData *aMutableData;
87
194
  long mark;
88
195
 
89
196
  aLocalFolder = (LocalFolder *)[self folder];
90
 
  aStream = [aLocalFolder stream];
91
 
 
 
197
  aStream = NULL;
 
198
 
 
199
  // If we are reading from a mbox file, the file is already open
 
200
  if ([self messageType] == MAILBOX_FORMAT_MBOX)
 
201
    {
 
202
      aStream = [aLocalFolder stream];
 
203
    }
 
204
  // we need to open the specific file
 
205
  else if ([self messageType] == MAILBOX_FORMAT_MAILDIR)
 
206
    { 
 
207
      aStream = fopen([[self mailFilename] cString], "r");
 
208
    }
 
209
 
 
210
  if ( !aStream )
 
211
    {
 
212
      NSDebugLog(@"Stream is null!");
 
213
      return nil;
 
214
    }
 
215
  
92
216
  mark = ftell(aStream);
93
 
 
 
217
  
94
218
  if (fseek(aStream, [self filePosition], SEEK_SET) < 0)
95
219
    {
96
 
      NSLog( @"Seek operation failed!" );
 
220
      NSDebugLog( @"Seek operation to position %d failed!", [self filePosition]);
97
221
      return nil;
98
222
    }
99
 
 
 
223
  
100
224
  // We initialize our mutable data and our buffer
101
225
  aMutableData = [[NSMutableData alloc] init];
102
 
  bzero(aLine, 1024);
 
226
  memset(aLine, 0, 1024);
103
227
 
104
 
  while( fgets(aLine, 1024, aStream) != NULL && 
105
 
         ftell(aStream) < ([self filePosition] + [self size]) )
 
228
  while ( fgets(aLine, 1024, aStream) != NULL && 
 
229
          ftell(aStream) < ([self filePosition] + [self size]) )
106
230
    {
107
231
      [aMutableData appendBytes: aLine  length: strlen(aLine) ];
108
 
      bzero(aLine, 1024);
 
232
      memset(aLine, 0, 1024);
109
233
    }
110
 
 
 
234
  
111
235
  fseek(aStream, mark, SEEK_SET);
112
 
 
 
236
  
 
237
  // If we are operating on a local file, close it.
 
238
  if ([self messageType] == MAILBOX_FORMAT_MAILDIR)
 
239
    {
 
240
      fclose(aStream);
 
241
    }
 
242
  
113
243
  return AUTORELEASE(aMutableData);
114
244
}
115
245
 
 
246
 
116
247
//
117
248
// This method is called to initialize the message if it wasn't.
118
249
// If we set it to NO and we HAD a content, we release the content;
123
254
 
124
255
  if ( aBOOL )
125
256
    {
126
 
      NSMutableData *aMutableData;
127
 
      LocalFolder *aLocalFolder;
128
 
      FILE *aStream;
129
 
      char aLine[1024];
130
 
      
131
 
      int lengthOfBody;
132
 
      long mark;
133
 
      
134
 
      
135
 
      aLocalFolder = (LocalFolder *)[self folder];
136
 
      aStream = [aLocalFolder stream];
137
 
      
138
 
      mark = ftell(aStream);
139
 
      
140
 
      if (fseek(aStream, [self bodyFilePosition], SEEK_SET) < 0)
141
 
        {
142
 
          NSLog( @"Seek operation failed!" );
 
257
      NSData *aData;
 
258
 
 
259
      aData = [self rawSource];
 
260
 
 
261
      if ( aData )
 
262
        {
 
263
          NSRange aRange;
 
264
 
 
265
          aRange = [aData rangeOfCString: "\n\n"];
 
266
          
 
267
          if (aRange.length == 0)
 
268
            {
 
269
              NSDebugLog(@"LocalMessage: Failed to initialize the message from data.");
 
270
              [super setInitialized: NO];
 
271
              return;
 
272
            }
 
273
          
 
274
          [self setHeadersFromData: [aData subdataWithRange: NSMakeRange(0,aRange.location)]];
 
275
          [self setContentFromRawSource:
 
276
                  [aData subdataWithRange:
 
277
                           NSMakeRange(aRange.location + 2, [aData length]-(aRange.location+2))]];
 
278
        }
 
279
      else
 
280
        {
 
281
          NSDebugLog(@"LocalMessage: Failed to get the raw source of the local message.");
143
282
          [super setInitialized: NO];
144
283
          return;
145
284
        }
146
 
     
147
 
      // We calculate the length of our body to make parsing faster
148
 
      lengthOfBody = ([self filePosition] + [self size] - [self bodyFilePosition]);
149
 
      aMutableData = [[NSMutableData alloc] initWithCapacity: lengthOfBody];
150
 
      
151
 
      bzero(aLine, 1024);
152
 
      while( fgets(aLine, 1024, aStream) != NULL && 
153
 
             ftell(aStream) < ([self filePosition] + [self size]) )
154
 
        {
155
 
          [aMutableData appendBytes: aLine  length: strlen(aLine) ];
156
 
          bzero(aLine, 1024);
157
 
        }
158
 
      
159
 
      
160
 
      fseek(aStream, mark, SEEK_SET);
161
 
      
162
 
      [self setContentFromRawSource: aMutableData];
163
 
      RELEASE(aMutableData);
164
285
    }
165
286
  else
166
287
    {
167
 
      TEST_RELEASE(content);
168
 
      content = nil;
169
 
    }
 
288
      DESTROY(content);
 
289
    }  
 
290
  
170
291
}
171
292
 
172
293
@end