po_hi_storage.h 8.99 KB
Newer Older
jdelange's avatar
jdelange committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
/*
 * This is a part of PolyORB-HI-C distribution, a minimal
 * middleware written for generated code from AADL models.
 * You should use it with the Ocarina toolsuite.
 *
 * For more informations, please visit http://assert-project.net/taste
 *
 * Copyright (C) 2011, European Space Agency.
 */

#ifndef __PO_HI_STORAGE_H__
#define __PO_HI_STORAGE_H__

#ifndef __PO_HI_FILENAME_MAXLENGTH
#define __PO_HI_FILENAME_MAXLENGTH 100
#endif

#ifndef __PO_HI_STORAGE_DIRECTORY_MAXFILES
#define __PO_HI_STORAGE_DIRECTORY_MAXFILES 100
#endif

#ifndef __PO_HI_STORAGE_PACKET_SIZE
#define __PO_HI_STORAGE_PACKET_SIZE sizeof(__po_hi_request_t)
#endif


#ifndef __PO_HI_STORAGE_MAX_PACKETS
#define __PO_HI_STORAGE_MAX_PACKETS 100
#endif

#ifndef __PO_HI_STORAGE_MAX_PACKET_STORES
#define __PO_HI_STORAGE_MAX_PACKET_STORES 100
#endif



typedef struct
{
   int         file_id;
   char        filename[__PO_HI_STORAGE_FILENAME_MAXLENGTH];
} __po_hi_storage_file_t;

typedef struct
{
   int         dir_id;
   char        filename[__PO_HI_STORAGE_DIRECTORY_MAXFILES][__PO_HI_FILENAME_MAXLENGTH];
} __po_hi_storage_dir_t;

typedef __po_hi_request_t __po_hi_storage_packet_t;

typedef struct
{
   __po_hi_storage_packet_t packets[__PO_HI_STORAGE_MAX_PACKETS];
} __po_hi_storage_packet_store_t;


/*
 * Files operations
 */

/**
 * \fn __po_hi_storage_file_open
 *
 * \brief Open a file designated as filename and complete the content of the
 * second parameter.
 *
 * Please note that this function just fills the structure passed as the
 * second parameter. It does not create the file, this is supposed to be
 * done by a separate function.
 *
 * Upon success, the function returns __PO_HI_SUCCESS.
 * It returns the following potential values:
 *  - __PO_HI_SUCCESS: successful operation
 *  - __PO_HI_TOOMANY: too may files are open at this time, cannot open more.
 *  - __PO_HI_INVALID: supplied filename is invalid
 */
int __po_hi_storage_file_open (const char* filename, __po_hi_storage_file_t*);

/**
 * \fn __po_hi_storage_file_create
 *
 * \brief Create the file on the filesystem.
 *
 * This function creates the file with the properties stored in the
 * second argument. The argument is the file to create.
 * The function can return the following values:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_ERROR_EXISTS     : File already exists
 * - __PO_HI_INVALID          : Invalid file
 */
int __po_hi_storage_file_create (const __po_hi_storage_file_t* file);

/**
 * \fn __po_hi_storage_file_read
 *
 * \brief Read part of a file.
 *
 * This function read a fixed length (part of) a file and
 * stores the content in a buffer. First argument is a file 
 * (previously opened with __po_hi_storage_file_open() ), the
 * second argument is the buffer to store the file content
 * while the last argument is the size to be read.
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file
 */
int __po_hi_storage_file_read (const __po_hi_storage_file_t* file, char* buf, int bufsize);

/**
 * \fn __po_hi_storage_file_write
 *
 * \brief Write part of a file.
 *
 * This function write a buffer in a file, at offset 0. 
 * First argument is a file 
 * (previously opened with __po_hi_storage_file_open() ), the
 * second argument is the buffer to write
 * while the last argument is the size to be written.
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file
 */
int __po_hi_storage_file_write (const __po_hi_storage_file_t* file, char* buf, int bufsize);

/**
 * \fn __po_hi_storage_file_delete
 *
 * \brief Delete a file.
 *
 * This function delete a file. The first argument is the file to be deleted
 * (previously opened with __po_hi_storage_file_open() ).
 * Result code are the following:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file
 * - __PO_HI_ERROR_NOEXISTS   : The file does not exists
 */
int __po_hi_storage_file_delete (const __po_hi_storage_file_t* file);

/**
 * \fn __po_hi_storage_file_rename
 *
 * \brief Rename a file.
 *
 * This function renames a file. The first argument is the original file
 * and the second argument the destination file.
 * (both were reviously opened with __po_hi_storage_file_open() ).
 * This function assumes there is no file that has already the name of the
 * second argument.
 *
 * Result code are the following:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file (either source or destination)
 * - __PO_HI_ERROR_NOEXISTS   : The source file (first argument) does not exists
 * - __PO_HI_ERROR_EXISTS     : The destination file (second argument) already
 *                              exists.
 */
int __po_hi_storage_file_rename (const __po_hi_storage_file_t* oldfile,const __po_hi_storage_file_t* newfile);

/**
 * \fn __po_hi_storage_file_append
 *
 * \brief Append content to a file.
 *
 * This function appends some data to an existing file.
 * This is as writting data at the last offset of the file.
 * First argument is a file (previously opened with 
 * __po_hi_storage_file_open() ), the
 * second argument is the buffer to write
 * while the last argument is the size to be written.
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file
 */
int __po_hi_storage_file_append (const __po_hi_storage_file_t* file, char* buf, int bufsize);

/**
 * \fn __po_hi_storage_file_replace
 *
 * \brief Replace a file.
 *
 * This function replace a file with another one. The first argument is the original file
 * and the second argument the file to be replaced.
 * (both were reviously opened with __po_hi_storage_file_open() ).
 * This function assumes there is already one file labelled under the
 * destination file.
 *
 * Result code are the following:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_ERROR_UNKNOWN    : Unknown error
 * - __PO_HI_INVALID          : Invalid file (either source or destination)
 * - __PO_HI_ERROR_NOEXISTS   : The source or destination file does not exists
 */
int __po_hi_storage_file_replace (const __po_hi_storage_file_t* oldfile, const __po_hi_file_t* newfile);


/**
 * \fn __po_hi_storage_file_lock
 *
 * \brief Lock a file
 *
 * This function locks a file, it acquires a lock on the file so that it
 * ensures that only one task is operating on it. If a call is issued while
 * the lock was already acquired, the second call will be put in the waiting
 * queue, waiting for the file to be unlocked. The behavior is basically like
 * a mutex.
 *
 * Result code are the following:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_INVALID          : Invalid file
 */
int __po_hi_storage_file_lock (const __po_hi_storage_file_t* file);

/**
 * \fn __po_hi_storage_file_unlock
 *
 * \brief Unlock a file
 *
 * This function unlocks a file, it releases a lock on the specified file.
 * The lock hqs to be acquired before using __po_hi_storage_file_lock().
 * Please note that calling this function when the file was not locked
 * results in an error.
 *
 * Result code are the following:
 * - __PO_HI_SUCCESS          : Successful operation
 * - __PO_HI_INVALID          : Invalid file
 * - __PO_HI_UNAVAILABLE      : The file was not locked.
 */

int __po_hi_storage_file_unlock (const __po_hi_storage_file_t* file);


/*
 * Directory operations
 */

int __po_hi_storage_directory_open (const char*, __po_hi_storage_dir_t*);

int __po_hi_storage_directory_create (const __po_hi_storage_dir_t*);

int __po_hi_storage_directory_delete (const __po_hi_storage_dir_t*);

int __po_hi_storage_directory_rename (const __po_hi_storage_dir_t* oldname, const __po_hi_storage_dir_t* newname);

int __po_hi_storage_directory_list (const __po_hi_storage_dir_t* dir);

int __po_hi_storage_directory_lock (const __po_hi_storage_dir_t* dir);

int __po_hi_storage_directory_unlock (const __po_hi_storage_dir_t* dir);

int __po_hi_storage_change_cdir (__po_hi_storage_dir_t* new_current_directory);

int __po_hi_storage_get_cdir (__po_hi_storage_dir_t* current_directory);


/*
 * Packets service
 */

int __po_hi_storage_packet_store_new (__po_hi_storage_packet_store_t* store);

int __po_hi_storage_packet_store_new_from_file (__po_hi_storage_packet_store_t* store, __po_hi_storage_file_t* file);

int __po_hi_storage_packet_store_write_to_file (__po_hi_storage_packet_store_t* store, __po_hi_storage_file_t* file);

int __po_hi_storage_packet_store_read (__po_hi_storage_packet_store_t* store, __po_hi_storage_packet_t*);

int __po_hi_storage_packet_store_write (__po_hi_storage_packet_store_t* store, __po_hi_storage_packet_t*);

int __po_hi_storage_packet_store_free (__po_hi_storage_packet_store_t* store, int n_free);

int __po_hi_storage_packet_store_status (__po_hi_storage_packet_store_t* store, __po_hi_storage_packet_store_status_t* status);


#endif /* __PO_HI_STORAGE_H__ */