← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/transmission/jaunty-security

« back to all changes in this revision

Viewing changes to libtransmission/bencode.h

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Starr-Bochicchio, Andrew Starr-Bochicchio, Martin Pitt
  • Date: 2009-02-26 11:55:50 UTC
  • mfrom: (1.1.21 upstream)
  • Revision ID: james.westby@ubuntu.com-20090226115550-3rnhgt9qhe3y6g74
Tags: 1.50-1ubuntu1
https://launchpad.net/bugs/329161
https://launchpad.net/bugs/334252
[ Andrew Starr-Bochicchio ]
* Merge from debian unstable (LP: #329161), remaining changes:
 - debian/control: 
  + Added replaces & provides clutch (now included as part of transmission).
  + Build-depends on quilt.
 - debian/rules: 
  + Uncommented "include /usr/share/quilt/quilt.make".
  + Added patch/unpatch targets for Quilt.
  + Create a PO template during package build.
 - 20_add_X-Ubuntu-Gettext-Domain.diff: Add X-Ubuntu-Gettext-Domain 
   to .desktop file.

[ Martin Pitt ]
* Add 01_check_notification_actions.diff: Check if notification
  agent supports actions, and do not use actions if not. (LP: #334252)

Show diffs side-by-side

added added

removed removed

Lines of Context:
libtransmission/bencode.h
1
1
/*
2
 
 * This file Copyright (C) 2008 Charles Kerr <charles@rebelbase.com>
 
2
 * This file Copyright (C) 2008-2009 Charles Kerr <charles@transmissionbt.com>
3
3
 *
4
4
 * This file is licensed by the GPL version 2.  Works owned by the
5
5
 * Transmission project are granted a special exemption to clause 2(b)
7
7
 * This exemption does not extend to derived works not owned by
8
8
 * the Transmission project.
9
9
 *
10
 
 * $Id: bencode.h 6795 2008-09-23 19:11:04Z charles $
 
10
 * $Id: bencode.h 7664 2009-01-11 17:46:51Z charles $
11
11
 */
12
12
 
13
13
#ifndef TR_BENCODE_H
15
15
 
16
16
#include <inttypes.h> /* for int64_t */
17
17
 
 
18
struct evbuffer;
 
19
 
18
20
enum
19
21
{
20
22
    TYPE_INT  = 1,
43
45
    } val;
44
46
} tr_benc;
45
47
 
 
48
#ifdef __cplusplus
 
49
extern "C" {
 
50
#endif
 
51
 
46
52
/***
47
53
****
48
54
***/
70
76
 
71
77
void      tr_bencFree( tr_benc * );
72
78
 
73
 
char*     tr_bencSave( const tr_benc * val,
74
 
                       int *           len );
75
 
 
76
 
char*     tr_bencSaveAsJSON( const tr_benc * top,
77
 
                             int *           len );
78
 
 
79
 
int       tr_bencSaveFile( const char * filename,
80
 
                           const        tr_benc * );
81
 
 
82
 
int       tr_bencSaveJSONFile( const char * filename,
83
 
                               const        tr_benc * );
84
 
 
85
 
void      tr_bencInitStr(                       tr_benc *,
86
 
                                   const void * str,
87
 
                                   int          str_len );
88
 
 
89
 
void      tr_bencInitRaw(                       tr_benc *,
90
 
                                   const void * raw,
91
 
                                   size_t       raw_len );
92
 
 
93
 
void      tr_bencInitInt(             tr_benc *,
94
 
                              int64_t num );
95
 
 
96
 
int       tr_bencInitDict(           tr_benc *,
97
 
                              size_t reserveCount );
98
 
 
99
 
int       tr_bencInitList(           tr_benc *,
100
 
                              size_t reserveCount );
 
79
char*     tr_bencSave( const tr_benc * val, int * len );
 
80
 
 
81
char*     tr_bencSaveAsJSON( const tr_benc * top, struct evbuffer * out );
 
82
 
 
83
int       tr_bencSaveFile( const char * filename, const tr_benc * );
 
84
 
 
85
int       tr_bencSaveJSONFile( const char * filename, const tr_benc * );
 
86
 
 
87
void      tr_bencInitStr( tr_benc *, const void * str, int str_len );
 
88
 
 
89
void      tr_bencInitRaw( tr_benc *, const void * raw, size_t raw_len );
 
90
 
 
91
void      tr_bencInitInt( tr_benc *, int64_t num );
 
92
 
 
93
int       tr_bencInitDict( tr_benc *, size_t reserveCount );
 
94
 
 
95
int       tr_bencInitList( tr_benc *, size_t reserveCount );
101
96
 
102
97
/***
103
98
****
104
99
***/
105
100
 
106
 
int       tr_bencListReserve(         tr_benc *,
107
 
                               size_t reserveCount );
 
101
int       tr_bencListReserve( tr_benc *, size_t reserveCount );
108
102
 
109
103
tr_benc * tr_bencListAdd( tr_benc * );
110
104
 
111
 
tr_benc * tr_bencListAddInt(                 tr_benc *,
112
 
                                     int64_t val );
113
 
 
114
 
tr_benc * tr_bencListAddStr(                           tr_benc *,
115
 
                                          const char * val );
116
 
 
117
 
tr_benc * tr_bencListAddList(               tr_benc *,
118
 
                                     size_t reserveCount );
119
 
 
120
 
tr_benc * tr_bencListAddDict(               tr_benc *,
121
 
                                     size_t reserveCount );
 
105
tr_benc * tr_bencListAddInt( tr_benc *, int64_t val );
 
106
 
 
107
tr_benc * tr_bencListAddStr( tr_benc *, const char * val );
 
108
 
 
109
tr_benc * tr_bencListAddList( tr_benc *, size_t reserveCount );
 
110
 
 
111
tr_benc * tr_bencListAddDict( tr_benc *, size_t reserveCount );
122
112
 
123
113
size_t    tr_bencListSize( const tr_benc * list );
124
114
 
125
 
tr_benc * tr_bencListChild( tr_benc * list,
126
 
                            size_t    n );
127
 
 
128
 
/***
129
 
****
130
 
***/
131
 
 
132
 
int       tr_bencDictReserve(         tr_benc *,
133
 
                               size_t reserveCount );
134
 
 
135
 
int       tr_bencDictRemove(                     tr_benc *,
136
 
                                    const char * key );
137
 
 
138
 
tr_benc * tr_bencDictAdd(                           tr_benc *,
139
 
                                       const char * key );
140
 
 
141
 
tr_benc * tr_bencDictAddDouble(                           tr_benc *,
142
 
                                             const char * key,
143
 
                                             double       d );
144
 
 
145
 
tr_benc * tr_bencDictAddInt(                           tr_benc *,
146
 
                                          const char * key,
147
 
                                          int64_t      val );
148
 
 
149
 
tr_benc * tr_bencDictAddStr(                           tr_benc *,
150
 
                                          const char * key,
151
 
                                          const char * val );
152
 
 
153
 
tr_benc * tr_bencDictAddList(                           tr_benc *,
154
 
                                           const char * key,
155
 
                                           size_t       reserve );
156
 
 
157
 
tr_benc * tr_bencDictAddDict(                           tr_benc *,
158
 
                                           const char * key,
159
 
                                           size_t       reserve );
160
 
 
161
 
tr_benc * tr_bencDictAddRaw(                           tr_benc *,
162
 
                                          const char * key,
163
 
                                          const        void *,
164
 
                                          size_t       len );
165
 
 
166
 
tr_benc*  tr_bencDictFind(                          tr_benc *,
167
 
                                       const char * key );
168
 
 
169
 
int       tr_bencDictFindList(                     tr_benc *,
170
 
                                      const char * key,
171
 
                                      tr_benc **   setme );
172
 
 
173
 
int       tr_bencDictFindDict(                     tr_benc *,
174
 
                                      const char * key,
175
 
                                      tr_benc **   setme );
176
 
 
177
 
int       tr_bencDictFindInt(                     tr_benc *,
178
 
                                     const char * key,
179
 
                                     int64_t *    setme );
180
 
 
181
 
int       tr_bencDictFindDouble(                     tr_benc *,
182
 
                                        const char * key,
183
 
                                        double *     setme );
184
 
 
185
 
int       tr_bencDictFindStr(                       tr_benc *,
186
 
                                      const char *  key,
187
 
                                      const char ** setme );
188
 
 
189
 
int       tr_bencDictFindRaw(                             tr_benc *,
190
 
                                         const char *     key,
191
 
                                         const uint8_t ** setme_raw,
192
 
                                         size_t *         setme_len );
193
 
 
194
 
/***
195
 
****
196
 
***/
197
 
 
198
 
int       tr_bencGetInt( const tr_benc * val,
199
 
                         int64_t *       setme );
200
 
 
201
 
int       tr_bencGetStr( const tr_benc * val,
202
 
                         const char **   setme );
203
 
 
204
 
int       tr_bencIsType( const tr_benc *,
205
 
                         int   type );
206
 
 
207
 
#define tr_bencIsInt( b )    tr_bencIsType( ( b ), TYPE_INT )
208
 
#define tr_bencIsDict( b )   tr_bencIsType( ( b ), TYPE_DICT )
209
 
#define tr_bencIsList( b )   tr_bencIsType( ( b ), TYPE_LIST )
210
 
#define tr_bencIsString( b ) tr_bencIsType( ( b ), TYPE_STR )
 
115
tr_benc * tr_bencListChild( tr_benc * list, size_t n );
 
116
 
 
117
/***
 
118
****
 
119
***/
 
120
 
 
121
int       tr_bencDictReserve( tr_benc *, size_t reserveCount );
 
122
 
 
123
int       tr_bencDictRemove( tr_benc *, const char * key );
 
124
 
 
125
tr_benc * tr_bencDictAdd( tr_benc *, const char * key );
 
126
 
 
127
tr_benc * tr_bencDictAddDouble( tr_benc *, const char * key, double );
 
128
 
 
129
tr_benc * tr_bencDictAddInt( tr_benc *, const char * key, int64_t );
 
130
 
 
131
tr_benc * tr_bencDictAddStr( tr_benc *, const char * key, const char * );
 
132
 
 
133
tr_benc * tr_bencDictAddList( tr_benc *, const char * key, size_t reserve );
 
134
 
 
135
tr_benc * tr_bencDictAddDict( tr_benc *, const char * key, size_t reserve );
 
136
 
 
137
tr_benc * tr_bencDictAddRaw( tr_benc *, const char * key,
 
138
                             const void * raw, size_t rawlen );
 
139
 
 
140
tr_benc*  tr_bencDictFind( tr_benc *, const char * key );
 
141
 
 
142
tr_bool   tr_bencDictFindList( tr_benc *, const char * key, tr_benc ** setme );
 
143
 
 
144
tr_bool   tr_bencDictFindDict( tr_benc *, const char * key, tr_benc ** setme );
 
145
 
 
146
tr_bool   tr_bencDictFindInt( tr_benc *, const char * key, int64_t * setme );
 
147
 
 
148
tr_bool   tr_bencDictFindDouble( tr_benc *, const char * key, double * setme );
 
149
 
 
150
tr_bool   tr_bencDictFindStr( tr_benc *, const char * key, const char ** setme );
 
151
 
 
152
tr_bool   tr_bencDictFindRaw( tr_benc *, const char * key,
 
153
                              const uint8_t ** setme_raw, size_t * setme_len );
 
154
 
 
155
/***
 
156
****
 
157
***/
 
158
 
 
159
tr_bool   tr_bencGetInt( const tr_benc * val, int64_t * setme );
 
160
 
 
161
tr_bool   tr_bencGetStr( const tr_benc * val, const char ** setme );
 
162
 
 
163
static TR_INLINE tr_bool tr_bencIsType  ( const tr_benc * b, int type ) { return ( b != NULL ) && ( b->type == type ); }
 
164
static TR_INLINE tr_bool tr_bencIsInt   ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_INT ); }
 
165
static TR_INLINE tr_bool tr_bencIsDict  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_DICT ); }
 
166
static TR_INLINE tr_bool tr_bencIsList  ( const tr_benc * b ) { return tr_bencIsType( b, TYPE_LIST ); }
 
167
static TR_INLINE tr_bool tr_bencIsString( const tr_benc * b ) { return tr_bencIsType( b, TYPE_STR ); }
211
168
 
212
169
/**
213
170
***  Treat these as private -- they're only made public here
225
182
                     const uint8_t ** setme_str,
226
183
                     size_t *         setme_strlen );
227
184
 
 
185
/**
 
186
***
 
187
**/
 
188
 
 
189
void  tr_bencMergeDicts( tr_benc * target, const tr_benc * source );
 
190
 
 
191
#ifdef __cplusplus
 
192
}
 
193
#endif
 
194
 
228
195
#endif