libarchive 0.1.1-mswin32 → 0.1.2-mswin32

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (9) hide show
  1. data/COPYING.libarchive +60 -60
  2. data/LICENSE.libbzip2 +42 -42
  3. data/README.txt +6 -6
  4. data/lib/i386-mswin32/rblibarchive.so +0 -0
  5. data/lib/libarchive.rb +1 -0
  6. data/lib/libarchive_ruby.rb +1 -0
  7. data/libarchive.c +1766 -1762
  8. metadata +25 -8
  9. data/lib/i386-mswin32/libarchive_ruby.so +0 -0
data/COPYING.libarchive CHANGED
@@ -1,60 +1,60 @@
1
- The libarchive distribution as a whole is Copyright by Tim Kientzle
2
- and is subject to the copyright notice reproduced at the bottom of
3
- this file.
4
-
5
- Each individual file in this distribution should have a clear
6
- copyright/licensing statement at the beginning of the file. If any do
7
- not, please let me know and I will rectify it. The following is
8
- intended to summarize the copyright status of the individual files;
9
- the actual statements in the files are controlling.
10
-
11
- * Except as listed below, all C sources (including .c and .h files)
12
- and documentation files are subject to the copyright notice reproduced
13
- at the bottom of this file.
14
-
15
- * The following source files are also subject in whole or in part to
16
- a 3-clause UC Regents copyright; please read the individual source
17
- files for details:
18
- libarchive/archive_entry.c
19
- libarchive/archive_read_support_compression_compress.c
20
- libarchive/archive_write_set_compression_compress.c
21
- libarchive/mtree.5
22
- tar/matching.c
23
-
24
- * The following source files are in the public domain:
25
- tar/getdate.y
26
-
27
- * The build files---including Makefiles, configure scripts,
28
- and auxiliary scripts used as part of the compile process---have
29
- widely varying licensing terms. Please check individual files before
30
- distributing them to see if those restrictions apply to you.
31
-
32
- I intend for all new source code to use the license below and hope over
33
- time to replace code with other licenses with new implementations that
34
- do use the license below. The varying licensing of the build scripts
35
- seems to be an unavoidable mess.
36
-
37
-
38
- Copyright (c) 2003-2008 <author(s)>
39
- All rights reserved.
40
-
41
- Redistribution and use in source and binary forms, with or without
42
- modification, are permitted provided that the following conditions
43
- are met:
44
- 1. Redistributions of source code must retain the above copyright
45
- notice, this list of conditions and the following disclaimer
46
- in this position and unchanged.
47
- 2. Redistributions in binary form must reproduce the above copyright
48
- notice, this list of conditions and the following disclaimer in the
49
- documentation and/or other materials provided with the distribution.
50
-
51
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
52
- IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
53
- OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
54
- IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
55
- INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
56
- NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57
- DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58
- THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59
- (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
60
- THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
1
+ The libarchive distribution as a whole is Copyright by Tim Kientzle
2
+ and is subject to the copyright notice reproduced at the bottom of
3
+ this file.
4
+
5
+ Each individual file in this distribution should have a clear
6
+ copyright/licensing statement at the beginning of the file. If any do
7
+ not, please let me know and I will rectify it. The following is
8
+ intended to summarize the copyright status of the individual files;
9
+ the actual statements in the files are controlling.
10
+
11
+ * Except as listed below, all C sources (including .c and .h files)
12
+ and documentation files are subject to the copyright notice reproduced
13
+ at the bottom of this file.
14
+
15
+ * The following source files are also subject in whole or in part to
16
+ a 3-clause UC Regents copyright; please read the individual source
17
+ files for details:
18
+ libarchive/archive_entry.c
19
+ libarchive/archive_read_support_compression_compress.c
20
+ libarchive/archive_write_set_compression_compress.c
21
+ libarchive/mtree.5
22
+ tar/matching.c
23
+
24
+ * The following source files are in the public domain:
25
+ tar/getdate.y
26
+
27
+ * The build files---including Makefiles, configure scripts,
28
+ and auxiliary scripts used as part of the compile process---have
29
+ widely varying licensing terms. Please check individual files before
30
+ distributing them to see if those restrictions apply to you.
31
+
32
+ I intend for all new source code to use the license below and hope over
33
+ time to replace code with other licenses with new implementations that
34
+ do use the license below. The varying licensing of the build scripts
35
+ seems to be an unavoidable mess.
36
+
37
+
38
+ Copyright (c) 2003-2008 <author(s)>
39
+ All rights reserved.
40
+
41
+ Redistribution and use in source and binary forms, with or without
42
+ modification, are permitted provided that the following conditions
43
+ are met:
44
+ 1. Redistributions of source code must retain the above copyright
45
+ notice, this list of conditions and the following disclaimer
46
+ in this position and unchanged.
47
+ 2. Redistributions in binary form must reproduce the above copyright
48
+ notice, this list of conditions and the following disclaimer in the
49
+ documentation and/or other materials provided with the distribution.
50
+
51
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
52
+ IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
53
+ OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
54
+ IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
55
+ INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
56
+ NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
57
+ DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
58
+ THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
59
+ (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
60
+ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
data/LICENSE.libbzip2 CHANGED
@@ -1,42 +1,42 @@
1
-
2
- --------------------------------------------------------------------------
3
-
4
- This program, "bzip2", the associated library "libbzip2", and all
5
- documentation, are copyright (C) 1996-2007 Julian R Seward. All
6
- rights reserved.
7
-
8
- Redistribution and use in source and binary forms, with or without
9
- modification, are permitted provided that the following conditions
10
- are met:
11
-
12
- 1. Redistributions of source code must retain the above copyright
13
- notice, this list of conditions and the following disclaimer.
14
-
15
- 2. The origin of this software must not be misrepresented; you must
16
- not claim that you wrote the original software. If you use this
17
- software in a product, an acknowledgment in the product
18
- documentation would be appreciated but is not required.
19
-
20
- 3. Altered source versions must be plainly marked as such, and must
21
- not be misrepresented as being the original software.
22
-
23
- 4. The name of the author may not be used to endorse or promote
24
- products derived from this software without specific prior written
25
- permission.
26
-
27
- THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
28
- OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
29
- WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30
- ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
31
- DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32
- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
33
- GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34
- INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
35
- WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36
- NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37
- SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38
-
39
- Julian Seward, jseward@bzip.org
40
- bzip2/libbzip2 version 1.0.5 of 10 December 2007
41
-
42
- --------------------------------------------------------------------------
1
+
2
+ --------------------------------------------------------------------------
3
+
4
+ This program, "bzip2", the associated library "libbzip2", and all
5
+ documentation, are copyright (C) 1996-2007 Julian R Seward. All
6
+ rights reserved.
7
+
8
+ Redistribution and use in source and binary forms, with or without
9
+ modification, are permitted provided that the following conditions
10
+ are met:
11
+
12
+ 1. Redistributions of source code must retain the above copyright
13
+ notice, this list of conditions and the following disclaimer.
14
+
15
+ 2. The origin of this software must not be misrepresented; you must
16
+ not claim that you wrote the original software. If you use this
17
+ software in a product, an acknowledgment in the product
18
+ documentation would be appreciated but is not required.
19
+
20
+ 3. Altered source versions must be plainly marked as such, and must
21
+ not be misrepresented as being the original software.
22
+
23
+ 4. The name of the author may not be used to endorse or promote
24
+ products derived from this software without specific prior written
25
+ permission.
26
+
27
+ THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
28
+ OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
29
+ WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
30
+ ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
31
+ DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
32
+ DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
33
+ GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34
+ INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
35
+ WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
36
+ NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
37
+ SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
38
+
39
+ Julian Seward, jseward@bzip.org
40
+ bzip2/libbzip2 version 1.0.5 of 10 December 2007
41
+
42
+ --------------------------------------------------------------------------
data/README.txt CHANGED
@@ -47,7 +47,7 @@ http://rubyforge.org/projects/libarchive
47
47
 
48
48
  == Source Code
49
49
 
50
- http://coderepos.org/share/browser/lang/ruby/libarchive/trunk/
50
+ https://github.com/winebarrel/Libarchive-Ruby
51
51
 
52
52
  == Dependency
53
53
 
@@ -61,7 +61,7 @@ gem install libarchive
61
61
 
62
62
  == Example
63
63
  === reading archive
64
- require 'libarchive_ruby'
64
+ require 'libarchive'
65
65
 
66
66
  Archive.read_open_filename('foo.tar.gz') do |ar|
67
67
  while entry = ar.next_header
@@ -78,9 +78,9 @@ gem install libarchive
78
78
  end
79
79
 
80
80
  === creating archive
81
- require 'libarchive_ruby'
81
+ require 'libarchive'
82
82
 
83
- Archive.write_open_filename('foo.tar.bz2', Archive::COMPRESSION_BZIP2, Archive::FORMAT_TAR_USTAR) do |ar|
83
+ Archive.write_open_filename('foo.tar.bz2', Archive::COMPRESSION_BZIP2, Archive::FORMAT_TAR) do |ar|
84
84
  Dir.glob('*.c').each do |fn|
85
85
  ar.new_entry do |entry|
86
86
  entry.copy_stat(fn)
@@ -98,7 +98,7 @@ gem install libarchive
98
98
  end
99
99
 
100
100
  === creating archive by extarnal program
101
- require 'libarchive_ruby'
101
+ require 'libarchive'
102
102
 
103
103
  Archive.write_open_filename('foo.tar.lzo', 'lzop', Archive::FORMAT_TAR_USTAR) do |ar|
104
104
  ...
@@ -135,7 +135,7 @@ gem install libarchive
135
135
  Libarchive/Ruby(mswin32) contains Libarchive(2.6.0) and libbzip2(1.0.5).
136
136
 
137
137
  * Libarchive
138
- * http://people.freebsd.org/~kientzle/libarchive/
138
+ * http://code.google.com/p/libarchive/
139
139
  * see {COPYING.libarchive}[link:files/COPYING_libarchive.html]
140
140
 
141
141
  * libbzip2
data/lib/libarchive.rb ADDED
@@ -0,0 +1 @@
1
+ require 'rblibarchive'
data/lib/libarchive_ruby.rb ADDED
@@ -0,0 +1 @@
1
+ require 'rblibarchive'
data/libarchive.c CHANGED
@@ -1,1762 +1,1766 @@
1
- #include "libarchive_internal.h"
2
-
3
- VALUE rb_mArchive;
4
- VALUE rb_eArchiveError;
5
-
6
- /* */
7
- VALUE rb_libarchive_s_version_number(VALUE self) {
8
- #if ARCHIVE_VERSION >= 2005000
9
- return INT2NUM(archive_version_number());
10
- #else
11
- return INT2NUM(archive_version_stamp());
12
- #endif
13
- }
14
-
15
- /* */
16
- VALUE rb_libarchive_s_version_string(VALUE self) {
17
- #if ARCHIVE_VERSION_NUMBER >= 2005000
18
- return rb_str_new2(archive_version_string());
19
- #else
20
- return rb_str_new2(archive_version());
21
- #endif
22
- }
23
-
24
- void DLLEXPORT Init_libarchive_ruby() {
25
- rb_mArchive = rb_define_module("Archive");
26
- rb_define_const(rb_mArchive, "VERSION", rb_str_new2(VERSION));
27
-
28
- rb_define_const(rb_mArchive, "COMPRESSION_NONE", INT2NUM(ARCHIVE_COMPRESSION_NONE));
29
- rb_define_const(rb_mArchive, "COMPRESSION_GZIP", INT2NUM(ARCHIVE_COMPRESSION_GZIP));
30
- rb_define_const(rb_mArchive, "COMPRESSION_BZIP2", INT2NUM(ARCHIVE_COMPRESSION_BZIP2));
31
- rb_define_const(rb_mArchive, "COMPRESSION_COMPRESS", INT2NUM(ARCHIVE_COMPRESSION_COMPRESS));
32
- // XXX:
33
- /*
34
- rb_define_const(rb_mArchive, "COMPRESSION_PROGRAM", INT2NUM(ARCHIVE_COMPRESSION_PROGRAM));
35
- rb_define_const(rb_mArchive, "COMPRESSION_LZMA", INT2NUM(ARCHIVE_COMPRESSION_LZMA));
36
- */
37
-
38
- rb_define_const(rb_mArchive, "FORMAT_BASE_MASK", INT2NUM(ARCHIVE_FORMAT_BASE_MASK));
39
- rb_define_const(rb_mArchive, "FORMAT_CPIO", INT2NUM(ARCHIVE_FORMAT_CPIO));
40
- rb_define_const(rb_mArchive, "FORMAT_CPIO_POSIX", INT2NUM(ARCHIVE_FORMAT_CPIO_POSIX));
41
- rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_LE", INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_LE));
42
- rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_BE", INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_BE));
43
- rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_NOCRC", INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_NOCRC));
44
- rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_CRC", INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_CRC));
45
- rb_define_const(rb_mArchive, "FORMAT_SHAR", INT2NUM(ARCHIVE_FORMAT_SHAR));
46
- rb_define_const(rb_mArchive, "FORMAT_SHAR_BASE", INT2NUM(ARCHIVE_FORMAT_SHAR_BASE));
47
- rb_define_const(rb_mArchive, "FORMAT_SHAR_DUMP", INT2NUM(ARCHIVE_FORMAT_SHAR_DUMP));
48
- rb_define_const(rb_mArchive, "FORMAT_TAR", INT2NUM(ARCHIVE_FORMAT_TAR));
49
- rb_define_const(rb_mArchive, "FORMAT_TAR_USTAR", INT2NUM(ARCHIVE_FORMAT_TAR_USTAR));
50
- rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_INTERCHANGE", INT2NUM(ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE));
51
- rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_RESTRICTED", INT2NUM(ARCHIVE_FORMAT_TAR_PAX_RESTRICTED));
52
- rb_define_const(rb_mArchive, "FORMAT_TAR_GNUTAR", INT2NUM(ARCHIVE_FORMAT_TAR_GNUTAR));
53
- rb_define_const(rb_mArchive, "FORMAT_ISO9660", INT2NUM(ARCHIVE_FORMAT_ISO9660));
54
- rb_define_const(rb_mArchive, "FORMAT_ISO9660_ROCKRIDGE", INT2NUM(ARCHIVE_FORMAT_ISO9660_ROCKRIDGE));
55
- rb_define_const(rb_mArchive, "FORMAT_ZIP", INT2NUM(ARCHIVE_FORMAT_ZIP));
56
- rb_define_const(rb_mArchive, "FORMAT_EMPTY", INT2NUM(ARCHIVE_FORMAT_EMPTY));
57
- rb_define_const(rb_mArchive, "FORMAT_AR", INT2NUM(ARCHIVE_FORMAT_AR));
58
- rb_define_const(rb_mArchive, "FORMAT_AR_GNU", INT2NUM(ARCHIVE_FORMAT_AR_GNU));
59
- rb_define_const(rb_mArchive, "FORMAT_AR_BSD", INT2NUM(ARCHIVE_FORMAT_AR_BSD));
60
- #ifdef ARCHIVE_FORMAT_MTREE
61
- rb_define_const(rb_mArchive, "FORMAT_MTREE", INT2NUM(ARCHIVE_FORMAT_MTREE));
62
- #endif
63
-
64
- rb_define_const(rb_mArchive, "EXTRACT_OWNER", INT2NUM(ARCHIVE_EXTRACT_OWNER));
65
- rb_define_const(rb_mArchive, "EXTRACT_PERM", INT2NUM(ARCHIVE_EXTRACT_PERM));
66
- rb_define_const(rb_mArchive, "EXTRACT_TIME", INT2NUM(ARCHIVE_EXTRACT_TIME));
67
- rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE", INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE));
68
- rb_define_const(rb_mArchive, "EXTRACT_UNLINK", INT2NUM(ARCHIVE_EXTRACT_UNLINK));
69
- rb_define_const(rb_mArchive, "EXTRACT_ACL", INT2NUM(ARCHIVE_EXTRACT_ACL));
70
- rb_define_const(rb_mArchive, "EXTRACT_FFLAGS", INT2NUM(ARCHIVE_EXTRACT_FFLAGS));
71
- rb_define_const(rb_mArchive, "EXTRACT_XATTR", INT2NUM(ARCHIVE_EXTRACT_XATTR));
72
- rb_define_const(rb_mArchive, "EXTRACT_SECURE_SYMLINKS", INT2NUM(ARCHIVE_EXTRACT_SECURE_SYMLINKS));
73
- rb_define_const(rb_mArchive, "EXTRACT_SECURE_NODOTDOT", INT2NUM(ARCHIVE_EXTRACT_SECURE_NODOTDOT));
74
- rb_define_const(rb_mArchive, "EXTRACT_NO_AUTODIR", INT2NUM(ARCHIVE_EXTRACT_NO_AUTODIR));
75
- rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE_NEWER", INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER));
76
- #ifdef ARCHIVE_EXTRACT_SPARSE
77
- rb_define_const(rb_mArchive, "EXTRACT_SPARSE", INT2NUM(ARCHIVE_EXTRACT_SPARSE));
78
- #endif
79
-
80
- rb_define_module_function(rb_mArchive, "version_number", rb_libarchive_s_version_number, 0);
81
- rb_define_module_function(rb_mArchive, "version_string", rb_libarchive_s_version_string, 0);
82
-
83
- rb_eArchiveError = rb_define_class_under(rb_mArchive, "Error", rb_eStandardError);
84
-
85
- Init_libarchive_reader();
86
- Init_libarchive_writer();
87
- Init_libarchive_archive();
88
- Init_libarchive_entry();
89
- }
90
- #include "libarchive_internal.h"
91
-
92
- extern VALUE rb_cArchiveReader;
93
- extern VALUE rb_cArchiveWriter;
94
- extern VALUE rb_eArchiveError;
95
-
96
- static void rb_libarchive_archive_free(struct rb_libarchive_archive_container *p) {
97
- xfree(p);
98
- }
99
-
100
- static void rb_libarchive_archive_mark(struct rb_libarchive_archive_container *p) {
101
- rb_gc_mark(p->memory);
102
- }
103
-
104
- VALUE rb_libarchive_archive_alloc(VALUE klass) {
105
- struct rb_libarchive_archive_container *p = ALLOC(struct rb_libarchive_archive_container);
106
- p->ar = NULL;
107
- p->eof = 0;
108
- p->memory = Qnil;
109
- return Data_Wrap_Struct(klass, rb_libarchive_archive_mark, rb_libarchive_archive_free, p);
110
- }
111
-
112
- /* */
113
- static VALUE rb_libarchive_archive_position_compressed(VALUE self) {
114
- struct rb_libarchive_archive_container *p;
115
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
116
- Check_Archive(p);
117
- return LL2NUM(archive_position_compressed(p->ar));
118
- }
119
-
120
- /* */
121
- static VALUE rb_libarchive_archive_position_uncompressed(VALUE self) {
122
- struct rb_libarchive_archive_container *p;
123
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
124
- Check_Archive(p);
125
- return LL2NUM(archive_position_uncompressed(p->ar));
126
- }
127
-
128
- /* */
129
- static VALUE rb_libarchive_archive_compression_name(VALUE self) {
130
- struct rb_libarchive_archive_container *p;
131
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
132
- Check_Archive(p);
133
- return rb_str_new2(archive_compression_name(p->ar));
134
- }
135
-
136
- /* */
137
- static VALUE rb_libarchive_archive_compression(VALUE self) {
138
- struct rb_libarchive_archive_container *p;
139
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
140
- Check_Archive(p);
141
- return INT2NUM(archive_compression(p->ar));
142
- }
143
-
144
- /* */
145
- static VALUE rb_libarchive_archive_format_name(VALUE self) {
146
- struct rb_libarchive_archive_container *p;
147
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
148
- Check_Archive(p);
149
- return rb_str_new2(archive_format_name(p->ar));
150
- }
151
-
152
- /* */
153
- static VALUE rb_libarchive_archive_format(VALUE self) {
154
- struct rb_libarchive_archive_container *p;
155
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
156
- Check_Archive(p);
157
- return NUM2INT(archive_format(p->ar));
158
- }
159
-
160
- void Init_libarchive_archive() {
161
- rb_define_method(rb_cArchiveReader, "position_compressed", rb_libarchive_archive_position_compressed, 0);
162
- rb_define_method(rb_cArchiveWriter, "position_compressed", rb_libarchive_archive_position_compressed, 0);
163
- rb_define_method(rb_cArchiveReader, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
164
- rb_define_method(rb_cArchiveWriter, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
165
- rb_define_method(rb_cArchiveReader, "compression_name", rb_libarchive_archive_compression_name, 0);
166
- rb_define_method(rb_cArchiveWriter, "compression_name", rb_libarchive_archive_compression_name, 0);
167
- rb_define_method(rb_cArchiveReader, "compression", rb_libarchive_archive_compression, 0);
168
- rb_define_method(rb_cArchiveWriter, "compression", rb_libarchive_archive_compression, 0);
169
- rb_define_method(rb_cArchiveReader, "format_name", rb_libarchive_archive_format_name, 0);
170
- rb_define_method(rb_cArchiveWriter, "format_name", rb_libarchive_archive_format_name, 0);
171
- rb_define_method(rb_cArchiveReader, "format", rb_libarchive_archive_format, 0);
172
- rb_define_method(rb_cArchiveWriter, "format", rb_libarchive_archive_format, 0);
173
- }
174
- #include "libarchive_internal.h"
175
-
176
- extern VALUE rb_mArchive;
177
- VALUE rb_cArchiveEntry;
178
- extern VALUE rb_eArchiveError;
179
-
180
- static void rb_libarchive_entry_free(struct rb_libarchive_entry_container *p) {
181
- xfree(p);
182
- }
183
-
184
- static VALUE rb_libarchive_entry_alloc(VALUE klass) {
185
- struct rb_libarchive_entry_container *p = ALLOC(struct rb_libarchive_entry_container);
186
- p->ae = NULL;
187
- p->must_close = 1;
188
- return Data_Wrap_Struct(klass, 0, rb_libarchive_entry_free, p);
189
- }
190
-
191
- /* */
192
- VALUE rb_libarchive_entry_close(VALUE self) {
193
- struct rb_libarchive_entry_container *p;
194
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
195
- Check_Entry(p);
196
-
197
- if (!p->must_close) {
198
- rb_raise(rb_eArchiveError, "Close entry failed: It is not necessary to close");
199
- }
200
-
201
- archive_entry_free(p->ae);
202
- p->ae = NULL;
203
- return Qnil;
204
- }
205
-
206
- VALUE rb_libarchive_entry_new(struct archive_entry *ae, int must_close) {
207
- VALUE entry;
208
- struct rb_libarchive_entry_container *p;
209
- entry = rb_funcall(rb_cArchiveEntry, rb_intern("new"), 0);
210
- Data_Get_Struct(entry, struct rb_libarchive_entry_container, p);
211
- p->ae = ae;
212
- p->must_close = must_close;
213
- return entry;
214
- }
215
-
216
- /* */
217
- static VALUE rb_libarchive_entry_atime(VALUE self) {
218
- struct rb_libarchive_entry_container *p;
219
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
220
- Check_Entry(p);
221
- return LONG2TIME((long) archive_entry_atime(p->ae));
222
- }
223
-
224
- /* */
225
- static VALUE rb_libarchive_entry_atime_nsec(VALUE self) {
226
- struct rb_libarchive_entry_container *p;
227
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
228
- Check_Entry(p);
229
- return LONG2NUM(archive_entry_atime_nsec(p->ae));
230
- }
231
-
232
- /* */
233
- static VALUE rb_libarchive_entry_atime_is_set(VALUE self) {
234
- struct rb_libarchive_entry_container *p;
235
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
236
- Check_Entry(p);
237
- return archive_entry_atime_is_set(p->ae) ? Qtrue : Qfalse;
238
- }
239
-
240
- /* */
241
- static VALUE rb_libarchive_entry_birthtime(VALUE self) {
242
- struct rb_libarchive_entry_container *p;
243
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
244
- Check_Entry(p);
245
- return LONG2TIME((long) archive_entry_birthtime(p->ae));
246
- }
247
-
248
- /* */
249
- static VALUE rb_libarchive_entry_birthtime_nsec(VALUE self) {
250
- struct rb_libarchive_entry_container *p;
251
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
252
- Check_Entry(p);
253
- return LONG2NUM(archive_entry_birthtime_nsec(p->ae));
254
- }
255
-
256
- /* */
257
- static VALUE rb_libarchive_entry_birthtime_is_set(VALUE self) {
258
- struct rb_libarchive_entry_container *p;
259
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
260
- Check_Entry(p);
261
- return archive_entry_birthtime_is_set(p->ae) ? Qtrue : Qfalse;
262
- }
263
-
264
- /* */
265
- static VALUE rb_libarchive_entry_ctime(VALUE self) {
266
- struct rb_libarchive_entry_container *p;
267
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
268
- Check_Entry(p);
269
- return LONG2TIME((long) archive_entry_ctime(p->ae));
270
- }
271
-
272
- /* */
273
- static VALUE rb_libarchive_entry_ctime_nsec(VALUE self) {
274
- struct rb_libarchive_entry_container *p;
275
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
276
- Check_Entry(p);
277
- return LONG2NUM(archive_entry_ctime_nsec(p->ae));
278
- }
279
-
280
- /* */
281
- static VALUE rb_libarchive_entry_ctime_is_set(VALUE self) {
282
- struct rb_libarchive_entry_container *p;
283
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
284
- Check_Entry(p);
285
- return archive_entry_ctime_is_set(p->ae) ? Qtrue : Qfalse;
286
- }
287
-
288
- /* */
289
- static VALUE rb_libarchive_entry_dev(VALUE self) {
290
- struct rb_libarchive_entry_container *p;
291
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
292
- Check_Entry(p);
293
- return LONG2NUM(archive_entry_dev(p->ae));
294
- }
295
-
296
- /* */
297
- static VALUE rb_libarchive_entry_devmajor(VALUE self) {
298
- struct rb_libarchive_entry_container *p;
299
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
300
- Check_Entry(p);
301
- return LONG2NUM(archive_entry_devmajor(p->ae));
302
- }
303
-
304
- /* */
305
- static VALUE rb_libarchive_entry_devminor(VALUE self) {
306
- struct rb_libarchive_entry_container *p;
307
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
308
- Check_Entry(p);
309
- return LONG2NUM(archive_entry_devminor(p->ae));
310
- }
311
-
312
- /* */
313
- static VALUE rb_libarchive_entry_filetype(VALUE self) {
314
- struct rb_libarchive_entry_container *p;
315
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
316
- Check_Entry(p);
317
- return INT2NUM(archive_entry_filetype(p->ae));
318
- }
319
-
320
- /* */
321
- static VALUE rb_libarchive_entry_is_directory(VALUE self) {
322
- struct rb_libarchive_entry_container *p;
323
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
324
- Check_Entry(p);
325
- return S_ISDIR(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
326
- }
327
-
328
- /* */
329
- static VALUE rb_libarchive_entry_is_character_special(VALUE self) {
330
- struct rb_libarchive_entry_container *p;
331
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
332
- Check_Entry(p);
333
- return S_ISCHR(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
334
- }
335
-
336
- /* */
337
- static VALUE rb_libarchive_entry_is_block_special(VALUE self) {
338
- struct rb_libarchive_entry_container *p;
339
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
340
- Check_Entry(p);
341
- return S_ISBLK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
342
- }
343
-
344
- /* */
345
- static VALUE rb_libarchive_entry_is_regular(VALUE self) {
346
- struct rb_libarchive_entry_container *p;
347
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
348
- Check_Entry(p);
349
- return S_ISREG(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
350
- }
351
-
352
- /* */
353
- static VALUE rb_libarchive_entry_is_symbolic_link(VALUE self) {
354
- struct rb_libarchive_entry_container *p;
355
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
356
- Check_Entry(p);
357
- return S_ISLNK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
358
- }
359
-
360
- /* */
361
- static VALUE rb_libarchive_entry_is_socket(VALUE self) {
362
- struct rb_libarchive_entry_container *p;
363
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
364
- Check_Entry(p);
365
- return S_ISSOCK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
366
- }
367
-
368
- /* */
369
- static VALUE rb_libarchive_entry_is_fifo(VALUE self) {
370
- struct rb_libarchive_entry_container *p;
371
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
372
- Check_Entry(p);
373
- return S_ISFIFO(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
374
- }
375
-
376
- /* */
377
- static VALUE rb_libarchive_entry_fflags(VALUE self) {
378
- struct rb_libarchive_entry_container *p;
379
- long set, clear;
380
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
381
- Check_Entry(p);
382
- archive_entry_fflags(p->ae, &set, &clear);
383
- return rb_ary_new3(2, LONG2NUM(set), LONG2NUM(clear));
384
- }
385
-
386
- /* */
387
- static VALUE rb_libarchive_entry_fflags_text(VALUE self) {
388
- struct rb_libarchive_entry_container *p;
389
- const char *fflags_text;
390
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
391
- Check_Entry(p);
392
- fflags_text = archive_entry_fflags_text(p->ae);
393
- return (fflags_text != NULL) ? rb_str_new2(fflags_text) : Qnil;
394
- }
395
-
396
- /* */
397
- static VALUE rb_libarchive_entry_gid(VALUE self) {
398
- struct rb_libarchive_entry_container *p;
399
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
400
- Check_Entry(p);
401
- return LONG2NUM(archive_entry_gid(p->ae));
402
- }
403
-
404
- /* */
405
- static VALUE rb_libarchive_entry_gname(VALUE self) {
406
- struct rb_libarchive_entry_container *p;
407
- const char *gname;
408
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
409
- Check_Entry(p);
410
- gname = archive_entry_gname(p->ae);
411
- return (gname != NULL) ? rb_str_new2(gname) : Qnil;
412
- }
413
-
414
- /* */
415
- static VALUE rb_libarchive_entry_hardlink(VALUE self) {
416
- struct rb_libarchive_entry_container *p;
417
- const char *hardlink;
418
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
419
- Check_Entry(p);
420
- hardlink = archive_entry_hardlink(p->ae);
421
- return (hardlink != NULL) ? rb_str_new2(hardlink) : Qnil;
422
- }
423
-
424
- /* */
425
- static VALUE rb_libarchive_entry_ino(VALUE self) {
426
- struct rb_libarchive_entry_container *p;
427
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
428
- return LONG2NUM(archive_entry_ino(p->ae));
429
- }
430
-
431
- /* */
432
- static VALUE rb_libarchive_entry_mode(VALUE self) {
433
- struct rb_libarchive_entry_container *p;
434
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
435
- return LONG2NUM(archive_entry_mode(p->ae));
436
- }
437
-
438
- /* */
439
- static VALUE rb_libarchive_entry_mtime(VALUE self) {
440
- struct rb_libarchive_entry_container *p;
441
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
442
- Check_Entry(p);
443
- return LONG2TIME((long) archive_entry_mtime(p->ae));
444
- }
445
-
446
- /* */
447
- static VALUE rb_libarchive_entry_mtime_nsec(VALUE self) {
448
- struct rb_libarchive_entry_container *p;
449
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
450
- Check_Entry(p);
451
- return LONG2NUM(archive_entry_mtime_nsec(p->ae));
452
- }
453
-
454
- /* */
455
- static VALUE rb_libarchive_entry_mtime_is_set(VALUE self) {
456
- struct rb_libarchive_entry_container *p;
457
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
458
- Check_Entry(p);
459
- return archive_entry_mtime_is_set(p->ae) ? Qtrue : Qfalse;
460
- }
461
-
462
- /* */
463
- static VALUE rb_libarchive_entry_nlink(VALUE self) {
464
- struct rb_libarchive_entry_container *p;
465
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
466
- Check_Entry(p);
467
- return LONG2NUM(archive_entry_nlink(p->ae));
468
- }
469
-
470
- /* */
471
- static VALUE rb_libarchive_entry_pathname(VALUE self) {
472
- struct rb_libarchive_entry_container *p;
473
- const char *pathname;
474
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
475
- Check_Entry(p);
476
- pathname = archive_entry_pathname(p->ae);
477
- return (pathname != NULL) ? rb_str_new2(pathname) : Qnil;
478
- }
479
-
480
- /* */
481
- static VALUE rb_libarchive_entry_rdev(VALUE self) {
482
- struct rb_libarchive_entry_container *p;
483
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
484
- Check_Entry(p);
485
- return LONG2NUM(archive_entry_rdev(p->ae));
486
- }
487
-
488
- /* */
489
- static VALUE rb_libarchive_entry_rdevmajor(VALUE self) {
490
- struct rb_libarchive_entry_container *p;
491
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
492
- Check_Entry(p);
493
- return LONG2NUM(archive_entry_rdevmajor(p->ae));
494
- }
495
-
496
- /* */
497
- static VALUE rb_libarchive_entry_rdevminor(VALUE self) {
498
- struct rb_libarchive_entry_container *p;
499
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
500
- Check_Entry(p);
501
- return LONG2NUM(archive_entry_rdevminor(p->ae));
502
- }
503
-
504
- #if ARCHIVE_VERSION_NUMBER >= 2005003
505
- /* */
506
- static VALUE rb_libarchive_entry_sourcepath(VALUE self) {
507
- struct rb_libarchive_entry_container *p;
508
- const char *sourcepath;
509
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
510
- Check_Entry(p);
511
- sourcepath = archive_entry_sourcepath(p->ae);
512
- return (sourcepath != NULL) ? rb_str_new2(sourcepath) : Qnil;
513
- }
514
- #endif
515
-
516
- /* */
517
- static VALUE rb_libarchive_entry_size(VALUE self) {
518
- struct rb_libarchive_entry_container *p;
519
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
520
- Check_Entry(p);
521
- return LL2NUM(archive_entry_size(p->ae));
522
- }
523
-
524
- /* */
525
- static VALUE rb_libarchive_entry_size_is_set(VALUE self) {
526
- struct rb_libarchive_entry_container *p;
527
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
528
- Check_Entry(p);
529
- return archive_entry_size_is_set(p->ae) ? Qtrue : Qfalse;
530
- }
531
-
532
- #if ARCHIVE_VERSION_NUMBER >= 2003002
533
- /* */
534
- static VALUE rb_libarchive_entry_strmode(VALUE self) {
535
- struct rb_libarchive_entry_container *p;
536
- const char *strmode;
537
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
538
- Check_Entry(p);
539
- strmode = archive_entry_strmode(p->ae);
540
- return (strmode != NULL) ? rb_str_new2(strmode) : Qnil;
541
- }
542
- #endif
543
-
544
- /* */
545
- static VALUE rb_libarchive_entry_symlink(VALUE self) {
546
- struct rb_libarchive_entry_container *p;
547
- const char *symlink;
548
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
549
- Check_Entry(p);
550
- symlink = archive_entry_symlink(p->ae);
551
- return (symlink != NULL) ? rb_str_new2(symlink) : Qnil;
552
- }
553
-
554
- /* */
555
- static VALUE rb_libarchive_entry_uid(VALUE self) {
556
- struct rb_libarchive_entry_container *p;
557
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
558
- Check_Entry(p);
559
- return LONG2NUM(archive_entry_uid(p->ae));
560
- }
561
-
562
- /* */
563
- static VALUE rb_libarchive_entry_uname(VALUE self) {
564
- struct rb_libarchive_entry_container *p;
565
- const char *uname;
566
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
567
- Check_Entry(p);
568
- uname = archive_entry_uname(p->ae);
569
- return (uname != NULL) ? rb_str_new2(uname) : Qnil;
570
- }
571
-
572
- /* */
573
- static VALUE rb_libarchive_entry_set_atime(VALUE self, VALUE v_time) {
574
- struct rb_libarchive_entry_container *p;
575
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
576
- Check_Entry(p);
577
- Check_Class(v_time, rb_cTime);
578
- archive_entry_set_atime(p->ae, TIME2LONG(v_time), 0);
579
- return Qnil;
580
- }
581
-
582
- /* */
583
- static VALUE rb_libarchive_entry_set_atime2(VALUE self, VALUE v_time, VALUE v_ns) {
584
- struct rb_libarchive_entry_container *p;
585
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
586
- Check_Entry(p);
587
- Check_Class(v_time, rb_cTime);
588
- Check_Type(v_ns, T_FIXNUM);
589
- archive_entry_set_atime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
590
- return Qnil;
591
- }
592
-
593
- /* */
594
- static VALUE rb_libarchive_entry_unset_atime(VALUE self) {
595
- struct rb_libarchive_entry_container *p;
596
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
597
- Check_Entry(p);
598
- archive_entry_unset_atime(p->ae);
599
- return Qnil;
600
- }
601
-
602
- /* */
603
- static VALUE rb_libarchive_entry_set_birthtime(VALUE self, VALUE v_time) {
604
- struct rb_libarchive_entry_container *p;
605
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
606
- Check_Entry(p);
607
- Check_Class(v_time, rb_cTime);
608
- archive_entry_set_birthtime(p->ae, TIME2LONG(v_time), 0);
609
- return Qnil;
610
- }
611
-
612
- /* */
613
- static VALUE rb_libarchive_entry_set_birthtime2(VALUE self, VALUE v_time, VALUE v_ns) {
614
- struct rb_libarchive_entry_container *p;
615
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
616
- Check_Entry(p);
617
- Check_Class(v_time, rb_cTime);
618
- Check_Type(v_ns, T_FIXNUM);
619
- archive_entry_set_birthtime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
620
- return Qnil;
621
- }
622
-
623
- /* */
624
- static VALUE rb_libarchive_entry_unset_birthtime(VALUE self) {
625
- struct rb_libarchive_entry_container *p;
626
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
627
- Check_Entry(p);
628
- archive_entry_unset_birthtime(p->ae);
629
- return Qnil;
630
- }
631
-
632
- /* */
633
- static VALUE rb_libarchive_entry_set_ctime(VALUE self, VALUE v_time) {
634
- struct rb_libarchive_entry_container *p;
635
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
636
- Check_Entry(p);
637
- Check_Class(v_time, rb_cTime);
638
- archive_entry_set_ctime(p->ae, TIME2LONG(v_time), 0);
639
- return Qnil;
640
- }
641
-
642
- /* */
643
- static VALUE rb_libarchive_entry_set_ctime2(VALUE self, VALUE v_time, VALUE v_ns) {
644
- struct rb_libarchive_entry_container *p;
645
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
646
- Check_Entry(p);
647
- Check_Class(v_time, rb_cTime);
648
- Check_Type(v_ns, T_FIXNUM);
649
- archive_entry_set_ctime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
650
- return Qnil;
651
- }
652
-
653
- /* */
654
- static VALUE rb_libarchive_entry_unset_ctime(VALUE self) {
655
- struct rb_libarchive_entry_container *p;
656
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
657
- Check_Entry(p);
658
- archive_entry_unset_ctime(p->ae);
659
- return Qnil;
660
- }
661
-
662
- /* */
663
- static VALUE rb_libarchive_entry_set_dev(VALUE self, VALUE v_dev) {
664
- struct rb_libarchive_entry_container *p;
665
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
666
- Check_Entry(p);
667
- Check_Type(v_dev, T_FIXNUM);
668
- archive_entry_set_dev(p->ae, NUM2LONG(v_dev));
669
- return Qnil;
670
- }
671
-
672
- /* */
673
- static VALUE rb_libarchive_entry_set_devmajor(VALUE self, VALUE v_dev) {
674
- struct rb_libarchive_entry_container *p;
675
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
676
- Check_Entry(p);
677
- Check_Type(v_dev, T_FIXNUM);
678
- archive_entry_set_devmajor(p->ae, NUM2LONG(v_dev));
679
- return Qnil;
680
- }
681
-
682
- /* */
683
- static VALUE rb_libarchive_entry_set_devminor(VALUE self, VALUE v_dev) {
684
- struct rb_libarchive_entry_container *p;
685
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
686
- Check_Entry(p);
687
- Check_Type(v_dev, T_FIXNUM);
688
- archive_entry_set_devminor(p->ae, NUM2LONG(v_dev));
689
- return Qnil;
690
- }
691
-
692
- /* */
693
- static VALUE rb_libarchive_entry_set_filetype(VALUE self, VALUE v_type) {
694
- struct rb_libarchive_entry_container *p;
695
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
696
- Check_Entry(p);
697
- Check_Type(v_type, T_FIXNUM);
698
- archive_entry_set_filetype(p->ae, NUM2LONG(v_type));
699
- return Qnil;
700
- }
701
-
702
- /* */
703
- static VALUE rb_libarchive_entry_set_fflags(VALUE self, VALUE v_set, VALUE v_clear) {
704
- struct rb_libarchive_entry_container *p;
705
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
706
- Check_Entry(p);
707
- Check_Type(v_set, T_FIXNUM);
708
- Check_Type(v_clear, T_FIXNUM);
709
- archive_entry_set_fflags(p->ae, (unsigned long) NUM2LONG(v_set), (unsigned long) NUM2LONG(v_clear));
710
- return Qnil;
711
- }
712
-
713
- /* */
714
- static VALUE rb_libarchive_entry_copy_fflags_text(VALUE self, VALUE v_fflags_text) {
715
- struct rb_libarchive_entry_container *p;
716
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
717
- Check_Entry(p);
718
- Check_Type(v_fflags_text, T_STRING);
719
- archive_entry_copy_fflags_text(p->ae, RSTRING_PTR(v_fflags_text));
720
- return Qnil;
721
- }
722
-
723
- /* */
724
- static VALUE rb_libarchive_entry_set_gid(VALUE self, VALUE v_gid) {
725
- struct rb_libarchive_entry_container *p;
726
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
727
- Check_Entry(p);
728
- Check_Type(v_gid, T_FIXNUM);
729
- archive_entry_set_gid(p->ae, NUM2LONG(v_gid));
730
- return Qnil;
731
- }
732
-
733
- /* */
734
- static VALUE rb_libarchive_entry_set_gname(VALUE self, VALUE v_gname) {
735
- struct rb_libarchive_entry_container *p;
736
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
737
- Check_Entry(p);
738
- Check_Type(v_gname, T_STRING);
739
- archive_entry_set_gname(p->ae, RSTRING_PTR(v_gname));
740
- return Qnil;
741
- }
742
-
743
- /* */
744
- static VALUE rb_libarchive_entry_copy_gname(VALUE self, VALUE v_gname) {
745
- struct rb_libarchive_entry_container *p;
746
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
747
- Check_Entry(p);
748
- Check_Type(v_gname, T_STRING);
749
- archive_entry_copy_gname(p->ae, RSTRING_PTR(v_gname));
750
- return Qnil;
751
- }
752
-
753
- /* */
754
- static VALUE rb_libarchive_entry_set_hardlink(VALUE self, VALUE v_hardlink) {
755
- struct rb_libarchive_entry_container *p;
756
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
757
- Check_Entry(p);
758
- Check_Type(v_hardlink, T_STRING);
759
- archive_entry_set_hardlink(p->ae, RSTRING_PTR(v_hardlink));
760
- return Qnil;
761
- }
762
-
763
- /* */
764
- static VALUE rb_libarchive_entry_copy_hardlink(VALUE self, VALUE v_hardlink) {
765
- struct rb_libarchive_entry_container *p;
766
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
767
- Check_Entry(p);
768
- Check_Type(v_hardlink, T_STRING);
769
- archive_entry_copy_hardlink(p->ae, RSTRING_PTR(v_hardlink));
770
- return Qnil;
771
- }
772
-
773
- /* */
774
- static VALUE rb_libarchive_entry_set_ino(VALUE self, VALUE v_ino) {
775
- struct rb_libarchive_entry_container *p;
776
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
777
- Check_Entry(p);
778
- Check_Type(v_ino, T_FIXNUM);
779
- archive_entry_set_ino(p->ae, (unsigned long) NUM2LONG(v_ino));
780
- return Qnil;
781
- }
782
-
783
- /* */
784
- static VALUE rb_libarchive_entry_set_link(VALUE self, VALUE v_link) {
785
- struct rb_libarchive_entry_container *p;
786
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
787
- Check_Entry(p);
788
- Check_Type(v_link, T_STRING);
789
- archive_entry_set_link(p->ae, RSTRING_PTR(v_link));
790
- return Qnil;
791
- }
792
-
793
- /* */
794
- static VALUE rb_libarchive_entry_copy_link(VALUE self, VALUE v_link) {
795
- struct rb_libarchive_entry_container *p;
796
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
797
- Check_Entry(p);
798
- Check_Type(v_link, T_STRING);
799
- archive_entry_copy_link(p->ae, RSTRING_PTR(v_link));
800
- return Qnil;
801
- }
802
-
803
- /* */
804
- static VALUE rb_libarchive_entry_set_mode(VALUE self, VALUE v_mode) {
805
- struct rb_libarchive_entry_container *p;
806
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
807
- Check_Entry(p);
808
- Check_Type(v_mode, T_STRING);
809
- archive_entry_set_mode(p->ae, NUM2INT(v_mode));
810
- return Qnil;
811
- }
812
-
813
- /* */
814
- static VALUE rb_libarchive_entry_set_mtime(VALUE self, VALUE v_time) {
815
- struct rb_libarchive_entry_container *p;
816
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
817
- Check_Entry(p);
818
- Check_Class(v_time, rb_cTime);
819
- archive_entry_set_mtime(p->ae, TIME2LONG(v_time), 0);
820
- return Qnil;
821
- }
822
-
823
- /* */
824
- static VALUE rb_libarchive_entry_set_mtime2(VALUE self, VALUE v_time, VALUE v_ns) {
825
- struct rb_libarchive_entry_container *p;
826
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
827
- Check_Entry(p);
828
- Check_Class(v_time, rb_cTime);
829
- Check_Type(v_ns, T_FIXNUM);
830
- archive_entry_set_mtime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
831
- return Qnil;
832
- }
833
-
834
- /* */
835
- static VALUE rb_libarchive_entry_unset_mtime(VALUE self) {
836
- struct rb_libarchive_entry_container *p;
837
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
838
- Check_Entry(p);
839
- archive_entry_unset_mtime(p->ae);
840
- return Qnil;
841
- }
842
-
843
- /* */
844
- static VALUE rb_libarchive_entry_set_nlink(VALUE self, VALUE v_nlink) {
845
- struct rb_libarchive_entry_container *p;
846
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
847
- Check_Entry(p);
848
- Check_Type(v_nlink, T_FIXNUM);
849
- archive_entry_set_nlink(p->ae, NUM2LONG(v_nlink));
850
- return Qnil;
851
- }
852
-
853
- /* */
854
- static VALUE rb_libarchive_entry_set_pathname(VALUE self, VALUE v_filename) {
855
- struct rb_libarchive_entry_container *p;
856
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
857
- Check_Entry(p);
858
- Check_Type(v_filename, T_STRING);
859
- archive_entry_set_pathname(p->ae, RSTRING_PTR(v_filename));
860
- return Qnil;
861
- }
862
-
863
- /* */
864
- static VALUE rb_libarchive_entry_copy_pathname(VALUE self, VALUE v_filename) {
865
- struct rb_libarchive_entry_container *p;
866
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
867
- Check_Entry(p);
868
- Check_Type(v_filename, T_STRING);
869
- archive_entry_copy_pathname(p->ae, RSTRING_PTR(v_filename));
870
- return Qnil;
871
- }
872
-
873
- /* */
874
- static VALUE rb_libarchive_entry_set_perm(VALUE self, VALUE v_perm) {
875
- struct rb_libarchive_entry_container *p;
876
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
877
- Check_Entry(p);
878
- Check_Type(v_perm, T_STRING);
879
- archive_entry_set_perm(p->ae, NUM2INT(v_perm));
880
- return Qnil;
881
- }
882
-
883
- /* */
884
- static VALUE rb_libarchive_entry_set_rdev(VALUE self, VALUE v_rdev) {
885
- struct rb_libarchive_entry_container *p;
886
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
887
- Check_Entry(p);
888
- Check_Type(v_rdev, T_FIXNUM);
889
- archive_entry_set_rdev(p->ae, NUM2LONG(v_rdev));
890
- return Qnil;
891
- }
892
-
893
- /* */
894
- static VALUE rb_libarchive_entry_set_rdevmajor(VALUE self, VALUE v_rdev) {
895
- struct rb_libarchive_entry_container *p;
896
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
897
- Check_Entry(p);
898
- Check_Type(v_rdev, T_FIXNUM);
899
- archive_entry_set_rdevmajor(p->ae, NUM2LONG(v_rdev));
900
- return Qnil;
901
- }
902
-
903
- /* */
904
- static VALUE rb_libarchive_entry_set_rdevminor(VALUE self, VALUE v_rdev) {
905
- struct rb_libarchive_entry_container *p;
906
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
907
- Check_Entry(p);
908
- Check_Type(v_rdev, T_FIXNUM);
909
- archive_entry_set_rdevminor(p->ae, NUM2LONG(v_rdev));
910
- return Qnil;
911
- }
912
-
913
- /* */
914
- static VALUE rb_libarchive_entry_set_size(VALUE self, VALUE v_size) {
915
- struct rb_libarchive_entry_container *p;
916
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
917
- Check_Entry(p);
918
- Check_Type(v_size, T_FIXNUM);
919
- archive_entry_set_size(p->ae, NUM2LL(v_size));
920
- return Qnil;
921
- }
922
-
923
- /* */
924
- static VALUE rb_libarchive_entry_unset_size(VALUE self) {
925
- struct rb_libarchive_entry_container *p;
926
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
927
- Check_Entry(p);
928
- archive_entry_unset_size(p->ae);
929
- return Qnil;
930
- }
931
-
932
- #if ARCHIVE_VERSION_NUMBER >= 2005003
933
- /* */
934
- static VALUE rb_libarchive_entry_copy_sourcepath(VALUE self, VALUE v_sourcepath) {
935
- struct rb_libarchive_entry_container *p;
936
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
937
- Check_Entry(p);
938
- Check_Type(v_sourcepath, T_STRING);
939
- archive_entry_copy_sourcepath(p->ae, RSTRING_PTR(v_sourcepath));
940
- return Qnil;
941
- }
942
- #endif
943
-
944
- /* */
945
- static VALUE rb_libarchive_entry_set_symlink(VALUE self, VALUE v_symlink) {
946
- struct rb_libarchive_entry_container *p;
947
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
948
- Check_Entry(p);
949
- Check_Type(v_symlink, T_STRING);
950
- archive_entry_set_symlink(p->ae, RSTRING_PTR(v_symlink));
951
- return Qnil;
952
- }
953
-
954
- /* */
955
- static VALUE rb_libarchive_entry_copy_symlink(VALUE self, VALUE v_symlink) {
956
- struct rb_libarchive_entry_container *p;
957
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
958
- Check_Entry(p);
959
- Check_Type(v_symlink, T_STRING);
960
- archive_entry_copy_symlink(p->ae, RSTRING_PTR(v_symlink));
961
- return Qnil;
962
- }
963
-
964
- /* */
965
- static VALUE rb_libarchive_entry_set_uid(VALUE self, VALUE v_uid) {
966
- struct rb_libarchive_entry_container *p;
967
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
968
- Check_Entry(p);
969
- Check_Type(v_uid, T_FIXNUM);
970
- archive_entry_set_uid(p->ae, NUM2LONG(v_uid));
971
- return Qnil;
972
- }
973
-
974
- /* */
975
- static VALUE rb_libarchive_entry_set_uname(VALUE self, VALUE v_uname) {
976
- struct rb_libarchive_entry_container *p;
977
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
978
- Check_Entry(p);
979
- Check_Type(v_uname, T_STRING);
980
- archive_entry_set_uname(p->ae, RSTRING_PTR(v_uname));
981
- return Qnil;
982
- }
983
-
984
- /* */
985
- static VALUE rb_libarchive_entry_copy_uname(VALUE self, VALUE v_uname) {
986
- struct rb_libarchive_entry_container *p;
987
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
988
- Check_Entry(p);
989
- Check_Type(v_uname, T_STRING);
990
- archive_entry_copy_uname(p->ae, RSTRING_PTR(v_uname));
991
- return Qnil;
992
- }
993
-
994
- /* */
995
- static VALUE rb_libarchive_entry_copy_stat(VALUE self, VALUE v_filename) {
996
- struct rb_libarchive_entry_container *p;
997
- const char *filename;
998
- struct stat s;
999
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1000
- Check_Entry(p);
1001
- Check_Type(v_filename, T_STRING);
1002
- filename = RSTRING_PTR(v_filename);
1003
-
1004
- if (stat(filename, &s) != 0) {
1005
- rb_raise(rb_eArchiveError, "Copy stat failed: %", strerror(errno));
1006
- }
1007
-
1008
- archive_entry_copy_stat(p->ae, &s);
1009
- return Qnil;
1010
- }
1011
-
1012
- /* */
1013
- static VALUE rb_libarchive_entry_copy_lstat(VALUE self, VALUE v_filename) {
1014
- struct rb_libarchive_entry_container *p;
1015
- const char *filename;
1016
- struct stat s;
1017
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1018
- Check_Entry(p);
1019
- Check_Type(v_filename, T_STRING);
1020
- filename = RSTRING_PTR(v_filename);
1021
-
1022
- if (lstat(filename, &s) != 0) {
1023
- rb_raise(rb_eArchiveError, "Copy stat failed: %", strerror(errno));
1024
- }
1025
-
1026
- archive_entry_copy_stat(p->ae, &s);
1027
- return Qnil;
1028
- }
1029
-
1030
- /* */
1031
- static VALUE rb_libarchive_entry_xattr_clear(VALUE self) {
1032
- struct rb_libarchive_entry_container *p;
1033
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1034
- Check_Entry(p);
1035
- archive_entry_xattr_clear(p->ae);
1036
- return Qnil;
1037
- }
1038
-
1039
- /* */
1040
- static VALUE rb_libarchive_entry_xattr_add_entry(VALUE self, VALUE v_name, VALUE v_value) {
1041
- struct rb_libarchive_entry_container *p;
1042
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1043
- Check_Entry(p);
1044
- Check_Type(v_name, T_STRING);
1045
- Check_Type(v_value, T_STRING);
1046
- archive_entry_xattr_add_entry(p->ae, RSTRING_PTR(v_name), RSTRING_PTR(v_value), RSTRING_LEN(v_value));
1047
- return Qnil;
1048
- }
1049
-
1050
- /* */
1051
- static VALUE rb_libarchive_entry_xattr_count(VALUE self) {
1052
- struct rb_libarchive_entry_container *p;
1053
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1054
- Check_Entry(p);
1055
- return INT2NUM(archive_entry_xattr_count(p->ae));
1056
- }
1057
-
1058
- /* */
1059
- static VALUE rb_libarchive_entry_xattr_reset(VALUE self) {
1060
- struct rb_libarchive_entry_container *p;
1061
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1062
- Check_Entry(p);
1063
- return INT2NUM(archive_entry_xattr_reset(p->ae));
1064
- }
1065
-
1066
- /* */
1067
- static VALUE rb_libarchive_entry_xattr_next(VALUE self) {
1068
- struct rb_libarchive_entry_container *p;
1069
- const char *name;
1070
- const void *value;
1071
- size_t size;
1072
- Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1073
- Check_Entry(p);
1074
-
1075
- if (archive_entry_xattr_next(p->ae, &name, &value, &size) != ARCHIVE_OK) {
1076
- return Qnil;
1077
- } else {
1078
- return rb_ary_new3(3, rb_str_new2(name), rb_str_new(value, size));
1079
- }
1080
- }
1081
-
1082
- void Init_libarchive_entry() {
1083
- rb_cArchiveEntry = rb_define_class_under(rb_mArchive, "Entry", rb_cObject);
1084
- rb_define_alloc_func(rb_cArchiveEntry, rb_libarchive_entry_alloc);
1085
- rb_funcall(rb_cArchiveEntry, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1086
- rb_define_method(rb_cArchiveEntry, "close", rb_libarchive_entry_close, 0);
1087
-
1088
- rb_define_method(rb_cArchiveEntry, "atime", rb_libarchive_entry_atime, 0);
1089
- rb_define_method(rb_cArchiveEntry, "atime_nsec", rb_libarchive_entry_atime_nsec, 0);
1090
- rb_define_method(rb_cArchiveEntry, "atime_is_set?", rb_libarchive_entry_atime_is_set, 0);
1091
- rb_define_method(rb_cArchiveEntry, "birthtime", rb_libarchive_entry_birthtime, 0);
1092
- rb_define_method(rb_cArchiveEntry, "birthtime_nsec", rb_libarchive_entry_birthtime_nsec, 0);
1093
- rb_define_method(rb_cArchiveEntry, "birthtime_is_set?", rb_libarchive_entry_birthtime_is_set, 0);
1094
- rb_define_method(rb_cArchiveEntry, "ctime", rb_libarchive_entry_ctime, 0);
1095
- rb_define_method(rb_cArchiveEntry, "ctime_nsec", rb_libarchive_entry_ctime_nsec, 0);
1096
- rb_define_method(rb_cArchiveEntry, "ctime_is_set?", rb_libarchive_entry_ctime_is_set, 0);
1097
- rb_define_method(rb_cArchiveEntry, "dev", rb_libarchive_entry_dev, 0);
1098
- rb_define_method(rb_cArchiveEntry, "devmajor", rb_libarchive_entry_devmajor, 0);
1099
- rb_define_method(rb_cArchiveEntry, "devminor", rb_libarchive_entry_devminor, 0);
1100
- rb_define_method(rb_cArchiveEntry, "filetype", rb_libarchive_entry_filetype, 0);
1101
- rb_define_method(rb_cArchiveEntry, "directory?", rb_libarchive_entry_is_directory, 0);
1102
- rb_define_method(rb_cArchiveEntry, "character_special?", rb_libarchive_entry_is_character_special, 0);
1103
- rb_define_method(rb_cArchiveEntry, "block_special?", rb_libarchive_entry_is_block_special, 0);
1104
- rb_define_method(rb_cArchiveEntry, "regular?", rb_libarchive_entry_is_regular, 0);
1105
- rb_define_method(rb_cArchiveEntry, "symbolic_link?", rb_libarchive_entry_is_symbolic_link, 0);
1106
- rb_define_method(rb_cArchiveEntry, "socket?", rb_libarchive_entry_is_socket, 0);
1107
- rb_define_method(rb_cArchiveEntry, "fifo?", rb_libarchive_entry_is_fifo, 0);
1108
- rb_define_method(rb_cArchiveEntry, "fflags", rb_libarchive_entry_fflags, 0);
1109
- rb_define_method(rb_cArchiveEntry, "fflags_text", rb_libarchive_entry_fflags_text, 0);
1110
- rb_define_method(rb_cArchiveEntry, "gid", rb_libarchive_entry_gid, 0);
1111
- rb_define_method(rb_cArchiveEntry, "gname", rb_libarchive_entry_gname, 0);
1112
- rb_define_method(rb_cArchiveEntry, "hardlink", rb_libarchive_entry_hardlink, 0);
1113
- rb_define_method(rb_cArchiveEntry, "ino", rb_libarchive_entry_ino, 0);
1114
- rb_define_method(rb_cArchiveEntry, "mode", rb_libarchive_entry_mode, 0);
1115
- rb_define_method(rb_cArchiveEntry, "mtime", rb_libarchive_entry_mtime, 0);
1116
- rb_define_method(rb_cArchiveEntry, "mtime_nsec", rb_libarchive_entry_mtime_nsec, 0);
1117
- rb_define_method(rb_cArchiveEntry, "mtime_is_set?", rb_libarchive_entry_mtime_is_set, 0);
1118
- rb_define_method(rb_cArchiveEntry, "nlink", rb_libarchive_entry_nlink, 0);
1119
- rb_define_method(rb_cArchiveEntry, "pathname", rb_libarchive_entry_pathname, 0);
1120
- rb_define_method(rb_cArchiveEntry, "rdev", rb_libarchive_entry_rdev, 0);
1121
- rb_define_method(rb_cArchiveEntry, "rdevmajor", rb_libarchive_entry_rdevmajor, 0);
1122
- rb_define_method(rb_cArchiveEntry, "rdevminor", rb_libarchive_entry_rdevminor, 0);
1123
- #if ARCHIVE_VERSION_NUMBER >= 2005003
1124
- rb_define_method(rb_cArchiveEntry, "sourcepath", rb_libarchive_entry_sourcepath, 0);
1125
- #endif
1126
- rb_define_method(rb_cArchiveEntry, "size", rb_libarchive_entry_size, 0);
1127
- rb_define_method(rb_cArchiveEntry, "size_is_set?", rb_libarchive_entry_size_is_set, 0);
1128
- #if ARCHIVE_VERSION_NUMBER >= 2003002
1129
- rb_define_method(rb_cArchiveEntry, "strmode", rb_libarchive_entry_strmode, 0);
1130
- #endif
1131
- rb_define_method(rb_cArchiveEntry, "symlink", rb_libarchive_entry_symlink, 0);
1132
- rb_define_method(rb_cArchiveEntry, "uid", rb_libarchive_entry_uid, 0);
1133
- rb_define_method(rb_cArchiveEntry, "uname", rb_libarchive_entry_uname, 0);
1134
-
1135
- rb_define_method(rb_cArchiveEntry, "atime=", rb_libarchive_entry_set_atime, 1);
1136
- rb_define_method(rb_cArchiveEntry, "set_atime", rb_libarchive_entry_set_atime2, 2);
1137
- rb_define_method(rb_cArchiveEntry, "unset_atime", rb_libarchive_entry_unset_atime, 0);
1138
- rb_define_method(rb_cArchiveEntry, "birthtimee=", rb_libarchive_entry_set_birthtime, 1);
1139
- rb_define_method(rb_cArchiveEntry, "set_birthtime", rb_libarchive_entry_set_birthtime2, 2);
1140
- rb_define_method(rb_cArchiveEntry, "unset_birthtime", rb_libarchive_entry_unset_birthtime, 0);
1141
- rb_define_method(rb_cArchiveEntry, "ctime=", rb_libarchive_entry_set_ctime, 1);
1142
- rb_define_method(rb_cArchiveEntry, "set_ctime", rb_libarchive_entry_set_ctime2, 2);
1143
- rb_define_method(rb_cArchiveEntry, "unset_ctime", rb_libarchive_entry_unset_ctime, 0);
1144
- rb_define_method(rb_cArchiveEntry, "dev=", rb_libarchive_entry_set_dev, 1);
1145
- rb_define_method(rb_cArchiveEntry, "devmajor=", rb_libarchive_entry_set_devmajor, 1);
1146
- rb_define_method(rb_cArchiveEntry, "devminor=", rb_libarchive_entry_set_devminor, 1);
1147
- rb_define_method(rb_cArchiveEntry, "filetype=", rb_libarchive_entry_set_filetype, 1);
1148
- rb_define_method(rb_cArchiveEntry, "set_fflags", rb_libarchive_entry_set_fflags, 2);
1149
- rb_define_method(rb_cArchiveEntry, "copy_fflags_text", rb_libarchive_entry_copy_fflags_text, 1);
1150
- rb_define_method(rb_cArchiveEntry, "gid=", rb_libarchive_entry_set_gid, 1);
1151
- rb_define_method(rb_cArchiveEntry, "gname=", rb_libarchive_entry_set_gname, 1);
1152
- rb_define_method(rb_cArchiveEntry, "copy_gname", rb_libarchive_entry_copy_gname, 1);
1153
- rb_define_method(rb_cArchiveEntry, "hardlink=", rb_libarchive_entry_set_hardlink, 1);
1154
- rb_define_method(rb_cArchiveEntry, "copy_hardlink", rb_libarchive_entry_copy_hardlink, 1);
1155
- rb_define_method(rb_cArchiveEntry, "ino=", rb_libarchive_entry_set_ino, 1);
1156
- rb_define_method(rb_cArchiveEntry, "link=", rb_libarchive_entry_set_link, 1);
1157
- rb_define_method(rb_cArchiveEntry, "copy_link", rb_libarchive_entry_copy_link, 1);
1158
- rb_define_method(rb_cArchiveEntry, "mode=", rb_libarchive_entry_set_mode, 1);
1159
- rb_define_method(rb_cArchiveEntry, "mtime=", rb_libarchive_entry_set_mtime, 1);
1160
- rb_define_method(rb_cArchiveEntry, "set_mtime", rb_libarchive_entry_set_mtime2, 2);
1161
- rb_define_method(rb_cArchiveEntry, "unset_mtime", rb_libarchive_entry_unset_mtime, 0);
1162
- rb_define_method(rb_cArchiveEntry, "nlink=", rb_libarchive_entry_set_nlink, 1);
1163
- rb_define_method(rb_cArchiveEntry, "pathname=", rb_libarchive_entry_set_pathname, 1);
1164
- rb_define_method(rb_cArchiveEntry, "copy_pathname", rb_libarchive_entry_copy_pathname, 1);
1165
- rb_define_method(rb_cArchiveEntry, "perm=", rb_libarchive_entry_set_perm, 1);
1166
- rb_define_method(rb_cArchiveEntry, "rdev=", rb_libarchive_entry_set_rdev, 1);
1167
- rb_define_method(rb_cArchiveEntry, "rdevmajor=", rb_libarchive_entry_set_rdevmajor, 1);
1168
- rb_define_method(rb_cArchiveEntry, "rdevminor=", rb_libarchive_entry_set_rdevminor, 1);
1169
- rb_define_method(rb_cArchiveEntry, "size=", rb_libarchive_entry_set_size, 1);
1170
- rb_define_method(rb_cArchiveEntry, "unset_size", rb_libarchive_entry_unset_size, 0);
1171
- #if ARCHIVE_VERSION_NUMBER >= 2005003
1172
- rb_define_method(rb_cArchiveEntry, "copy_sourcepath", rb_libarchive_entry_copy_sourcepath, 1);
1173
- #endif
1174
- rb_define_method(rb_cArchiveEntry, "symlink=", rb_libarchive_entry_set_symlink, 1);
1175
- rb_define_method(rb_cArchiveEntry, "copy_symlink", rb_libarchive_entry_copy_symlink, 1);
1176
- rb_define_method(rb_cArchiveEntry, "uid=", rb_libarchive_entry_set_uid, 1);
1177
- rb_define_method(rb_cArchiveEntry, "uname=", rb_libarchive_entry_set_uname, 1);
1178
- rb_define_method(rb_cArchiveEntry, "copy_uname", rb_libarchive_entry_copy_uname, 1);
1179
-
1180
- rb_define_method(rb_cArchiveEntry, "copy_stat", rb_libarchive_entry_copy_stat, 1);
1181
- rb_define_method(rb_cArchiveEntry, "copy_lstat", rb_libarchive_entry_copy_lstat, 1);
1182
-
1183
- rb_define_method(rb_cArchiveEntry, "xattr_clear", rb_libarchive_entry_xattr_clear, 0);
1184
- rb_define_method(rb_cArchiveEntry, "xattr_add_entry", rb_libarchive_entry_xattr_add_entry, 2);
1185
- rb_define_method(rb_cArchiveEntry, "xattr_count", rb_libarchive_entry_xattr_count, 0);
1186
- rb_define_method(rb_cArchiveEntry, "xattr_reset", rb_libarchive_entry_xattr_reset, 0);
1187
- rb_define_method(rb_cArchiveEntry, "xattr_next", rb_libarchive_entry_xattr_next, 0);
1188
- }
1189
- #include "libarchive_internal.h"
1190
-
1191
- extern VALUE rb_mArchive;
1192
- VALUE rb_cArchiveReader;
1193
- extern VALUE rb_eArchiveError;
1194
- extern VALUE rb_cArchiveEntry;
1195
-
1196
- static void rb_libarchive_reader_close0(struct rb_libarchive_archive_container *p) {
1197
- archive_read_close(p->ar);
1198
- archive_read_finish(p->ar);
1199
- p->ar = NULL;
1200
- }
1201
-
1202
- /* */
1203
- static VALUE rb_libarchive_reader_close(VALUE self) {
1204
- struct rb_libarchive_archive_container *p;
1205
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1206
- Check_Archive(p);
1207
- rb_libarchive_reader_close0(p);
1208
- return Qnil;
1209
- }
1210
-
1211
- static VALUE rb_libarchive_reader_s_open0(int (*archive_open)(struct rb_libarchive_archive_container *, void *), void *arg, int compression, int format, const char *cmd) {
1212
- VALUE reader;
1213
- struct rb_libarchive_archive_container *p;
1214
- int r;
1215
- reader = rb_funcall(rb_cArchiveReader, rb_intern("new"), 0);
1216
- Data_Get_Struct(reader, struct rb_libarchive_archive_container, p);
1217
-
1218
- if ((p->ar = archive_read_new()) == NULL) {
1219
- rb_raise(rb_eArchiveError, "Open reader failed: %s", strerror(errno));
1220
- }
1221
-
1222
- if (cmd != NULL) {
1223
- r = archive_read_support_compression_program(p->ar, cmd);
1224
- } else if (compression != -1) {
1225
- r = archive_read_support_compression(p->ar, compression);
1226
- } else {
1227
- r = archive_read_support_compression_all(p->ar);
1228
- }
1229
-
1230
- if (r != ARCHIVE_OK) {
1231
- char error_string[BUFSIZ];
1232
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1233
- rb_libarchive_reader_close0(p);
1234
- rb_raise(rb_eArchiveError, "Support compression failed: %s", error_string);
1235
- }
1236
-
1237
- if (format != -1) {
1238
- r = archive_read_support_format(p->ar, format);
1239
- } else {
1240
- r = archive_read_support_format_all(p->ar);
1241
- }
1242
-
1243
- if (r != ARCHIVE_OK) {
1244
- char error_string[BUFSIZ];
1245
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1246
- rb_libarchive_reader_close0(p);
1247
- rb_raise(rb_eArchiveError, "Support format failed: %s", error_string);
1248
- }
1249
-
1250
- if (archive_open(p, arg) != ARCHIVE_OK) {
1251
- char error_string[BUFSIZ];
1252
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1253
- rb_libarchive_reader_close0(p);
1254
- rb_raise(rb_eArchiveError, "Open reader failed: %s", error_string);
1255
- }
1256
-
1257
- if (rb_block_given_p()) {
1258
- VALUE retval;
1259
- int status;
1260
- retval = rb_protect(rb_yield, reader, &status);
1261
- rb_libarchive_reader_close0(p);
1262
-
1263
- if (status != 0) {
1264
- rb_jump_tag(status);
1265
- }
1266
-
1267
- return retval;
1268
- } else {
1269
- return reader;
1270
- }
1271
- }
1272
-
1273
- static int rb_libarchive_reader_s_open_filename0(struct rb_libarchive_archive_container *p, void *arg) {
1274
- const char *filename = (const char *) arg;
1275
-
1276
- if (filename != NULL) {
1277
- struct stat s;
1278
-
1279
- if (stat(filename, &s) != 0) {
1280
- archive_set_error(p->ar, -1, strerror(errno));
1281
- return (ARCHIVE_FATAL);
1282
- }
1283
- }
1284
-
1285
- return archive_read_open_filename(p->ar, filename, BLOCK_SIZE);
1286
- }
1287
-
1288
- /* */
1289
- static VALUE rb_libarchive_reader_s_open_filename(int argc, VALUE *argv, VALUE self) {
1290
- VALUE v_filename, v_compression, v_format;
1291
- const char *filename = NULL;
1292
- int compression = -1, format = -1;
1293
- const char *cmd = NULL;
1294
- rb_scan_args(argc, argv, "12", &v_filename, &v_compression, &v_format);
1295
- Check_Type(v_filename, T_STRING);
1296
- filename = RSTRING_PTR(v_filename);
1297
-
1298
- if (T_STRING == TYPE(v_compression)) {
1299
- compression = -1;
1300
- cmd = RSTRING_PTR(v_compression);
1301
- } else if (!NIL_P(v_compression)) {
1302
- compression = NUM2INT(v_compression);
1303
- }
1304
-
1305
- if (!NIL_P(v_format)) {
1306
- format = NUM2INT(v_format);
1307
- }
1308
-
1309
- return rb_libarchive_reader_s_open0(rb_libarchive_reader_s_open_filename0, (void *) filename, compression, format, cmd);
1310
- }
1311
-
1312
- static int rb_libarchive_reader_s_open_memory0(struct rb_libarchive_archive_container *p, void *arg) {
1313
- VALUE v_buff = (VALUE) arg;
1314
- return archive_read_open_memory(p->ar, RSTRING_PTR(v_buff), RSTRING_LEN(v_buff));
1315
- }
1316
-
1317
- /* */
1318
- static VALUE rb_libarchive_reader_s_open_memory(int argc, VALUE *argv, VALUE self) {
1319
- VALUE v_memory, v_compression, v_format;
1320
- int compression = -1, format = -1;
1321
- const char *cmd = NULL;
1322
- rb_scan_args(argc, argv, "12", &v_memory, &v_compression, &v_format);
1323
- Check_Type(v_memory, T_STRING);
1324
-
1325
- if (T_STRING == TYPE(v_compression)) {
1326
- compression = -1;
1327
- cmd = RSTRING_PTR(v_compression);
1328
- } else if (!NIL_P(v_compression)) {
1329
- compression = NUM2INT(v_compression);
1330
- }
1331
-
1332
- if (!NIL_P(v_format)) {
1333
- format = NUM2INT(v_format);
1334
- }
1335
-
1336
- return rb_libarchive_reader_s_open0(rb_libarchive_reader_s_open_memory0, (void *) v_memory, compression, format, cmd);
1337
- }
1338
-
1339
- /* */
1340
- static VALUE rb_libarchive_reader_next_header(VALUE self) {
1341
- struct rb_libarchive_archive_container *p;
1342
- struct archive_entry *ae;
1343
- int r;
1344
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1345
- Check_Archive(p);
1346
-
1347
- if (p->eof) {
1348
- return Qnil;
1349
- }
1350
-
1351
- r = archive_read_next_header(p->ar, &ae);
1352
-
1353
- if (r == ARCHIVE_EOF) {
1354
- p->eof = 1;
1355
- return Qnil;
1356
- } else if (r != ARCHIVE_OK) {
1357
- rb_raise(rb_eArchiveError, "Fetch entry failed: %s", archive_error_string(p->ar));
1358
- }
1359
-
1360
- return rb_libarchive_entry_new(ae, 0);
1361
- }
1362
-
1363
- /* */
1364
- static VALUE rb_libarchive_reader_header_position(VALUE self) {
1365
- struct rb_libarchive_archive_container *p;
1366
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1367
- Check_Archive(p);
1368
- return LONG2NUM((long) archive_read_header_position(p->ar));
1369
- }
1370
-
1371
- /* */
1372
- static VALUE rb_libarchive_reader_read_data(int argc, VALUE *argv, VALUE self) {
1373
- VALUE v_size;
1374
- struct rb_libarchive_archive_container *p;
1375
- char *buff;
1376
- size_t size = DATA_BUFFER_SIZE;
1377
- ssize_t n;
1378
- rb_scan_args(argc, argv, "01", &v_size);
1379
-
1380
- if (!NIL_P(v_size)) {
1381
- size = NUM2INT(v_size);
1382
- }
1383
-
1384
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1385
- Check_Archive(p);
1386
-
1387
- if (p->eof) {
1388
- return Qnil;
1389
- }
1390
-
1391
- if (rb_block_given_p()) {
1392
- ssize_t len = 0;
1393
- int status = 0;
1394
- buff = xmalloc(size);
1395
-
1396
- while ((n = archive_read_data(p->ar, buff, size)) > 0) {
1397
- rb_protect(rb_yield, rb_str_new(buff, n), &status);
1398
-
1399
- if (status != 0) {
1400
- break;
1401
- }
1402
-
1403
- len += n;
1404
- }
1405
-
1406
- xfree(buff);
1407
-
1408
- if (status != 0) {
1409
- rb_jump_tag(status);
1410
- }
1411
-
1412
- if (n < 0) {
1413
- rb_raise(rb_eArchiveError, "Read data failed: %s", archive_error_string(p->ar));
1414
- }
1415
-
1416
- return LONG2NUM(len);
1417
- } else {
1418
- VALUE retval = rb_str_new("", 0);
1419
- buff = xmalloc(size);
1420
-
1421
- while ((n = archive_read_data(p->ar, buff, size)) > 0) {
1422
- rb_str_cat(retval, buff, n);
1423
- }
1424
-
1425
- xfree(buff);
1426
-
1427
- if (n < 0) {
1428
- rb_raise(rb_eArchiveError, "Read data failed: %s", archive_error_string(p->ar));
1429
- }
1430
-
1431
- return retval;
1432
- }
1433
- }
1434
-
1435
- /* */
1436
- static VALUE rb_libarchive_reader_save_data(int argc, VALUE *argv, VALUE self) {
1437
- VALUE v_filename, v_flags;
1438
- struct rb_libarchive_archive_container *p;
1439
- const char *filename;
1440
- int flags, fd, r;
1441
- rb_scan_args(argc, argv, "11", &v_filename, &v_flags);
1442
- Check_Type(v_filename, T_STRING);
1443
- filename = RSTRING_PTR(v_filename);
1444
-
1445
- if (!NIL_P(v_flags)) {
1446
- flags = ((O_WRONLY | NUM2INT(v_flags)) & O_FLAGS);
1447
- } else {
1448
- flags = (O_WRONLY | O_CREAT | O_EXCL
1449
- #ifdef O_BINARY
1450
- | O_BINARY
1451
- #endif
1452
- );
1453
- }
1454
-
1455
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1456
- Check_Archive(p);
1457
-
1458
- if ((fd = open(filename, flags)) == -1) {
1459
- rb_raise(rb_eArchiveError, "Save data failed: %s", strerror(errno));
1460
- }
1461
-
1462
- r = archive_read_data_into_fd(p->ar, fd);
1463
- _close(fd);
1464
-
1465
- if (r != ARCHIVE_OK) {
1466
- rb_raise(rb_eArchiveError, "Save data failed: %s", archive_error_string(p->ar));
1467
- }
1468
-
1469
- return Qnil;
1470
- }
1471
-
1472
- /* */
1473
- static VALUE rb_libarchive_reader_extract(int argc, VALUE *argv, VALUE self) {
1474
- VALUE v_entry, v_flags;
1475
- struct rb_libarchive_archive_container *pa;
1476
- struct rb_libarchive_entry_container *pae;
1477
- int flags = 0;
1478
- rb_scan_args(argc, argv, "11", &v_entry, &v_flags);
1479
- Check_Class(v_entry, rb_cArchiveEntry);
1480
-
1481
- if (!NIL_P(v_flags)) {
1482
- flags = (NUM2INT(v_flags) & EXTRACT_FLAGS);
1483
- }
1484
-
1485
- Data_Get_Struct(self, struct rb_libarchive_archive_container, pa);
1486
- Check_Archive(pa);
1487
-
1488
- if (pa->eof) {
1489
- rb_raise(rb_eArchiveError, "Extract archive failed: It has already reached EOF");
1490
- }
1491
-
1492
- Data_Get_Struct(v_entry, struct rb_libarchive_entry_container, pae);
1493
- Check_Entry(pae);
1494
-
1495
- if (archive_read_extract(pa->ar, pae->ae, flags) != ARCHIVE_OK) {
1496
- rb_raise(rb_eArchiveError, "Extract archive failed: %s", archive_error_string(pa->ar));
1497
- }
1498
-
1499
- return Qnil;
1500
- }
1501
-
1502
- void Init_libarchive_reader() {
1503
- rb_cArchiveReader = rb_define_class_under(rb_mArchive, "Reader", rb_cObject);
1504
- rb_define_alloc_func(rb_cArchiveReader, rb_libarchive_archive_alloc);
1505
- rb_funcall(rb_cArchiveReader, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1506
- rb_define_singleton_method(rb_cArchiveReader, "open_filename", rb_libarchive_reader_s_open_filename, -1);
1507
- rb_define_module_function(rb_mArchive, "read_open_filename", rb_libarchive_reader_s_open_filename, -1);
1508
- rb_define_singleton_method(rb_cArchiveReader, "open_memory", rb_libarchive_reader_s_open_memory, -1);
1509
- rb_define_module_function(rb_mArchive, "read_open_memory", rb_libarchive_reader_s_open_memory, -1);
1510
- rb_define_method(rb_cArchiveReader, "close", rb_libarchive_reader_close, 0);
1511
- rb_define_method(rb_cArchiveReader, "next_header", rb_libarchive_reader_next_header, 0);
1512
- rb_define_method(rb_cArchiveReader, "header_position", rb_libarchive_reader_header_position, 0);
1513
- rb_define_method(rb_cArchiveReader, "read_data", rb_libarchive_reader_read_data, -1);
1514
- rb_define_method(rb_cArchiveReader, "save_data", rb_libarchive_reader_save_data, -1);
1515
- rb_define_method(rb_cArchiveReader, "extract", rb_libarchive_reader_extract, -1);
1516
- }
1517
- #include "libarchive_internal.h"
1518
-
1519
- extern VALUE rb_mArchive;
1520
- VALUE rb_cArchiveWriter;
1521
- extern VALUE rb_eArchiveError;
1522
- extern VALUE rb_cArchiveEntry;
1523
-
1524
- static void rb_libarchive_writer_close0(struct rb_libarchive_archive_container *p) {
1525
- archive_write_close(p->ar);
1526
- archive_write_finish(p->ar);
1527
- p->ar = NULL;
1528
- }
1529
-
1530
- /* */
1531
- static VALUE rb_libarchive_writer_close(VALUE self) {
1532
- struct rb_libarchive_archive_container *p;
1533
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1534
- Check_Archive(p);
1535
- rb_libarchive_writer_close0(p);
1536
- return Qnil;
1537
- }
1538
-
1539
- static VALUE rb_libarchive_writer_s_open0(int (*archive_open)(struct rb_libarchive_archive_container *, void *), void *arg, int compression, int format, const char *cmd) {
1540
- VALUE writer;
1541
- struct rb_libarchive_archive_container *p;
1542
- int r;
1543
- writer = rb_funcall(rb_cArchiveWriter, rb_intern("new"), 0);
1544
- Data_Get_Struct(writer, struct rb_libarchive_archive_container, p);
1545
-
1546
- if ((p->ar = archive_write_new()) == NULL) {
1547
- rb_raise(rb_eArchiveError, "Open writer failed: %s", strerror(errno));
1548
- }
1549
-
1550
- if (cmd != NULL) {
1551
- r = archive_write_set_compression_program(p->ar, cmd);
1552
- } else {
1553
- r = archive_write_set_compression(p->ar, compression);
1554
- }
1555
-
1556
- if (r != ARCHIVE_OK) {
1557
- char error_string[BUFSIZ];
1558
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1559
- rb_libarchive_writer_close0(p);
1560
- rb_raise(rb_eArchiveError, "Set compression failed: %s", error_string);
1561
- }
1562
-
1563
- if (archive_write_set_format(p->ar, format) != ARCHIVE_OK) {
1564
- char error_string[BUFSIZ];
1565
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1566
- rb_libarchive_writer_close0(p);
1567
- rb_raise(rb_eArchiveError, "Set format failed: %s", error_string);
1568
- }
1569
-
1570
- if (archive_open(p, arg) != ARCHIVE_OK) {
1571
- char error_string[BUFSIZ];
1572
- archive_copy_error_string(p->ar, error_string, BUFSIZ);
1573
- rb_libarchive_writer_close0(p);
1574
- rb_raise(rb_eArchiveError, "Open writer failed: %s", error_string);
1575
- }
1576
-
1577
- if (rb_block_given_p()) {
1578
- VALUE retval;
1579
- int status;
1580
- retval = rb_protect(rb_yield, writer, &status);
1581
- rb_libarchive_writer_close0(p);
1582
-
1583
- if (status != 0) {
1584
- rb_jump_tag(status);
1585
- }
1586
-
1587
- return retval;
1588
- } else {
1589
- return writer;
1590
- }
1591
- }
1592
-
1593
- static int rb_libarchive_writer_s_open_filename0(struct rb_libarchive_archive_container *p, void *arg) {
1594
- const char *filename = (const char *) arg;
1595
- return archive_write_open_filename(p->ar, filename);
1596
- }
1597
-
1598
- /* */
1599
- static VALUE rb_libarchive_writer_s_open_filename(VALUE self, VALUE v_filename, VALUE v_compression, VALUE v_format) {
1600
- const char *filename = NULL;
1601
- int compression, format;
1602
- const char *cmd = NULL;
1603
- Check_Type(v_filename, T_STRING);
1604
-
1605
- if (RSTRING_LEN(v_filename) < 1) {
1606
- rb_raise(rb_eArchiveError, "Open writer failed: No such file or directory");
1607
- }
1608
-
1609
- filename = RSTRING_PTR(v_filename);
1610
-
1611
- if (T_STRING == TYPE(v_compression)) {
1612
- compression = -1;
1613
- cmd = RSTRING_PTR(v_compression);
1614
- } else {
1615
- compression = NUM2INT(v_compression);
1616
- }
1617
-
1618
-
1619
- format = NUM2INT(v_format);
1620
- return rb_libarchive_writer_s_open0(rb_libarchive_writer_s_open_filename0, (void *) filename, compression, format, cmd);
1621
- }
1622
-
1623
- static int rb_libarchive_writer_s_open_memory0(struct rb_libarchive_archive_container *p, void *arg) {
1624
- VALUE str = (VALUE) arg;
1625
- p->memory = str;
1626
- return archive_write_open_rb_str(p->ar, str);
1627
- }
1628
-
1629
- /* */
1630
- static VALUE rb_libarchive_writer_s_open_memory(VALUE self, VALUE v_memory, VALUE v_compression, VALUE v_format) {
1631
- int compression, format;
1632
- const char *cmd = NULL;
1633
- Check_Type(v_memory, T_STRING);
1634
-
1635
- if (T_STRING == TYPE(v_compression)) {
1636
- compression = -1;
1637
- cmd = RSTRING_PTR(v_compression);
1638
- } else {
1639
- compression = NUM2INT(v_compression);
1640
- }
1641
-
1642
- format = NUM2INT(v_format);
1643
- return rb_libarchive_writer_s_open0(rb_libarchive_writer_s_open_memory0, (void *) v_memory, compression, format, cmd);
1644
- }
1645
-
1646
- /* */
1647
- static VALUE rb_libarchive_writer_new_entry(VALUE self) {
1648
- VALUE entry;
1649
- struct rb_libarchive_archive_container *p;
1650
- struct archive_entry *ae;
1651
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1652
- Check_Archive(p);
1653
-
1654
- if ((ae = archive_entry_new()) == NULL) {
1655
- rb_raise(rb_eArchiveError, "New entry failed: %s", strerror(errno));
1656
- }
1657
-
1658
- entry = rb_libarchive_entry_new(ae, 1);
1659
-
1660
- if (rb_block_given_p()) {
1661
- VALUE retval;
1662
- int status;
1663
- retval = rb_protect(rb_yield, entry, &status);
1664
- rb_libarchive_entry_close(entry);
1665
-
1666
- if (status != 0) {
1667
- rb_jump_tag(status);
1668
- }
1669
-
1670
- return retval;
1671
- } else {
1672
- return entry;
1673
- }
1674
- }
1675
-
1676
- /* */
1677
- static VALUE rb_libarchive_writer_write_header(VALUE self, VALUE v_entry) {
1678
- struct rb_libarchive_archive_container *pa;
1679
- struct rb_libarchive_entry_container *pae;
1680
- Check_Class(v_entry, rb_cArchiveEntry);
1681
- Data_Get_Struct(self, struct rb_libarchive_archive_container, pa);
1682
- Check_Archive(pa);
1683
- Data_Get_Struct(v_entry, struct rb_libarchive_entry_container, pae);
1684
- Check_Entry(pae);
1685
-
1686
- if (archive_write_header(pa->ar, pae->ae) != ARCHIVE_OK) {
1687
- rb_raise(rb_eArchiveError, "Write header failed: %s", archive_error_string(pa->ar));
1688
- }
1689
-
1690
- return Qnil;
1691
- }
1692
-
1693
- static ssize_t rb_libarchive_writer_write_data0(struct archive *ar, VALUE v_buff) {
1694
- const char *buff;
1695
- size_t size;
1696
- ssize_t n;
1697
-
1698
- if (NIL_P(v_buff)) {
1699
- return 0;
1700
- }
1701
-
1702
- Check_Type(v_buff, T_STRING);
1703
- buff = RSTRING_PTR(v_buff);
1704
- size = RSTRING_LEN(v_buff);
1705
-
1706
- if (size < 1) {
1707
- return 0;
1708
- }
1709
-
1710
- if ((n = archive_write_data(ar, buff, size)) < 0) {
1711
- rb_raise(rb_eArchiveError, "Write data failed: %s", archive_error_string(ar));
1712
- }
1713
-
1714
- return n;
1715
- }
1716
-
1717
- /* */
1718
- static VALUE rb_libarchive_writer_write_data(int argc, VALUE *argv, VALUE self) {
1719
- struct rb_libarchive_archive_container *p;
1720
- Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1721
- Check_Archive(p);
1722
-
1723
- if (rb_block_given_p()) {
1724
- ssize_t len = 0;
1725
-
1726
- if (argc > 0) {
1727
- rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
1728
- }
1729
-
1730
- while(1) {
1731
- VALUE retval;
1732
- ssize_t n;
1733
- retval = rb_yield(Qnil);
1734
-
1735
- if ((n = rb_libarchive_writer_write_data0(p->ar, retval)) < 1) {
1736
- return LONG2NUM(len);
1737
- }
1738
-
1739
- len += n;
1740
- }
1741
- } else {
1742
- VALUE v_buff;
1743
- ssize_t n;
1744
- rb_scan_args(argc, argv, "10", &v_buff);
1745
- n = rb_libarchive_writer_write_data0(p->ar, v_buff);
1746
- return LONG2NUM(n);
1747
- }
1748
- }
1749
-
1750
- void Init_libarchive_writer() {
1751
- rb_cArchiveWriter = rb_define_class_under(rb_mArchive, "Writer", rb_cObject);
1752
- rb_define_alloc_func(rb_cArchiveWriter, rb_libarchive_archive_alloc);
1753
- rb_funcall(rb_cArchiveWriter, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1754
- rb_define_singleton_method(rb_cArchiveWriter, "open_filename", rb_libarchive_writer_s_open_filename, 3);
1755
- rb_define_singleton_method(rb_mArchive, "write_open_filename", rb_libarchive_writer_s_open_filename, 3);
1756
- rb_define_singleton_method(rb_cArchiveWriter, "open_memory", rb_libarchive_writer_s_open_memory, 3);
1757
- rb_define_singleton_method(rb_mArchive, "write_open_memory", rb_libarchive_writer_s_open_memory, 3);
1758
- rb_define_method(rb_cArchiveWriter, "close", rb_libarchive_writer_close, 0);
1759
- rb_define_method(rb_cArchiveWriter, "new_entry", rb_libarchive_writer_new_entry, 0);
1760
- rb_define_method(rb_cArchiveWriter, "write_header", rb_libarchive_writer_write_header, 1);
1761
- rb_define_method(rb_cArchiveWriter, "write_data", rb_libarchive_writer_write_data, -1);
1762
- }
1
+ #include "libarchive_internal.h"
2
+
3
+ VALUE rb_mArchive;
4
+ VALUE rb_eArchiveError;
5
+
6
+ /* */
7
+ VALUE rb_libarchive_s_version_number(VALUE self) {
8
+ #if ARCHIVE_VERSION >= 2005000
9
+ return INT2NUM(archive_version_number());
10
+ #else
11
+ return INT2NUM(archive_version_stamp());
12
+ #endif
13
+ }
14
+
15
+ /* */
16
+ VALUE rb_libarchive_s_version_string(VALUE self) {
17
+ #if ARCHIVE_VERSION_NUMBER >= 2005000
18
+ return rb_str_new2(archive_version_string());
19
+ #else
20
+ return rb_str_new2(archive_version());
21
+ #endif
22
+ }
23
+
24
+ void DLLEXPORT Init_rblibarchive() {
25
+ rb_mArchive = rb_define_module("Archive");
26
+ rb_define_const(rb_mArchive, "VERSION", rb_str_new2(VERSION));
27
+
28
+ rb_define_const(rb_mArchive, "COMPRESSION_NONE", INT2NUM(ARCHIVE_COMPRESSION_NONE));
29
+ #ifdef HAVE_ZLIB_H
30
+ rb_define_const(rb_mArchive, "COMPRESSION_GZIP", INT2NUM(ARCHIVE_COMPRESSION_GZIP));
31
+ #endif
32
+ #ifdef HAVE_BZLIB_H
33
+ rb_define_const(rb_mArchive, "COMPRESSION_BZIP2", INT2NUM(ARCHIVE_COMPRESSION_BZIP2));
34
+ #endif
35
+ rb_define_const(rb_mArchive, "COMPRESSION_COMPRESS", INT2NUM(ARCHIVE_COMPRESSION_COMPRESS));
36
+ // XXX:
37
+ /*
38
+ rb_define_const(rb_mArchive, "COMPRESSION_PROGRAM", INT2NUM(ARCHIVE_COMPRESSION_PROGRAM));
39
+ rb_define_const(rb_mArchive, "COMPRESSION_LZMA", INT2NUM(ARCHIVE_COMPRESSION_LZMA));
40
+ */
41
+
42
+ rb_define_const(rb_mArchive, "FORMAT_BASE_MASK", INT2NUM(ARCHIVE_FORMAT_BASE_MASK));
43
+ rb_define_const(rb_mArchive, "FORMAT_CPIO", INT2NUM(ARCHIVE_FORMAT_CPIO));
44
+ rb_define_const(rb_mArchive, "FORMAT_CPIO_POSIX", INT2NUM(ARCHIVE_FORMAT_CPIO_POSIX));
45
+ rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_LE", INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_LE));
46
+ rb_define_const(rb_mArchive, "FORMAT_CPIO_BIN_BE", INT2NUM(ARCHIVE_FORMAT_CPIO_BIN_BE));
47
+ rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_NOCRC", INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_NOCRC));
48
+ rb_define_const(rb_mArchive, "FORMAT_CPIO_SVR4_CRC", INT2NUM(ARCHIVE_FORMAT_CPIO_SVR4_CRC));
49
+ rb_define_const(rb_mArchive, "FORMAT_SHAR", INT2NUM(ARCHIVE_FORMAT_SHAR));
50
+ rb_define_const(rb_mArchive, "FORMAT_SHAR_BASE", INT2NUM(ARCHIVE_FORMAT_SHAR_BASE));
51
+ rb_define_const(rb_mArchive, "FORMAT_SHAR_DUMP", INT2NUM(ARCHIVE_FORMAT_SHAR_DUMP));
52
+ rb_define_const(rb_mArchive, "FORMAT_TAR", INT2NUM(ARCHIVE_FORMAT_TAR));
53
+ rb_define_const(rb_mArchive, "FORMAT_TAR_USTAR", INT2NUM(ARCHIVE_FORMAT_TAR_USTAR));
54
+ rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_INTERCHANGE", INT2NUM(ARCHIVE_FORMAT_TAR_PAX_INTERCHANGE));
55
+ rb_define_const(rb_mArchive, "FORMAT_TAR_PAX_RESTRICTED", INT2NUM(ARCHIVE_FORMAT_TAR_PAX_RESTRICTED));
56
+ rb_define_const(rb_mArchive, "FORMAT_TAR_GNUTAR", INT2NUM(ARCHIVE_FORMAT_TAR_GNUTAR));
57
+ rb_define_const(rb_mArchive, "FORMAT_ISO9660", INT2NUM(ARCHIVE_FORMAT_ISO9660));
58
+ rb_define_const(rb_mArchive, "FORMAT_ISO9660_ROCKRIDGE", INT2NUM(ARCHIVE_FORMAT_ISO9660_ROCKRIDGE));
59
+ rb_define_const(rb_mArchive, "FORMAT_ZIP", INT2NUM(ARCHIVE_FORMAT_ZIP));
60
+ rb_define_const(rb_mArchive, "FORMAT_EMPTY", INT2NUM(ARCHIVE_FORMAT_EMPTY));
61
+ rb_define_const(rb_mArchive, "FORMAT_AR", INT2NUM(ARCHIVE_FORMAT_AR));
62
+ rb_define_const(rb_mArchive, "FORMAT_AR_GNU", INT2NUM(ARCHIVE_FORMAT_AR_GNU));
63
+ rb_define_const(rb_mArchive, "FORMAT_AR_BSD", INT2NUM(ARCHIVE_FORMAT_AR_BSD));
64
+ #ifdef ARCHIVE_FORMAT_MTREE
65
+ rb_define_const(rb_mArchive, "FORMAT_MTREE", INT2NUM(ARCHIVE_FORMAT_MTREE));
66
+ #endif
67
+
68
+ rb_define_const(rb_mArchive, "EXTRACT_OWNER", INT2NUM(ARCHIVE_EXTRACT_OWNER));
69
+ rb_define_const(rb_mArchive, "EXTRACT_PERM", INT2NUM(ARCHIVE_EXTRACT_PERM));
70
+ rb_define_const(rb_mArchive, "EXTRACT_TIME", INT2NUM(ARCHIVE_EXTRACT_TIME));
71
+ rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE", INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE));
72
+ rb_define_const(rb_mArchive, "EXTRACT_UNLINK", INT2NUM(ARCHIVE_EXTRACT_UNLINK));
73
+ rb_define_const(rb_mArchive, "EXTRACT_ACL", INT2NUM(ARCHIVE_EXTRACT_ACL));
74
+ rb_define_const(rb_mArchive, "EXTRACT_FFLAGS", INT2NUM(ARCHIVE_EXTRACT_FFLAGS));
75
+ rb_define_const(rb_mArchive, "EXTRACT_XATTR", INT2NUM(ARCHIVE_EXTRACT_XATTR));
76
+ rb_define_const(rb_mArchive, "EXTRACT_SECURE_SYMLINKS", INT2NUM(ARCHIVE_EXTRACT_SECURE_SYMLINKS));
77
+ rb_define_const(rb_mArchive, "EXTRACT_SECURE_NODOTDOT", INT2NUM(ARCHIVE_EXTRACT_SECURE_NODOTDOT));
78
+ rb_define_const(rb_mArchive, "EXTRACT_NO_AUTODIR", INT2NUM(ARCHIVE_EXTRACT_NO_AUTODIR));
79
+ rb_define_const(rb_mArchive, "EXTRACT_NO_OVERWRITE_NEWER", INT2NUM(ARCHIVE_EXTRACT_NO_OVERWRITE_NEWER));
80
+ #ifdef ARCHIVE_EXTRACT_SPARSE
81
+ rb_define_const(rb_mArchive, "EXTRACT_SPARSE", INT2NUM(ARCHIVE_EXTRACT_SPARSE));
82
+ #endif
83
+
84
+ rb_define_module_function(rb_mArchive, "version_number", rb_libarchive_s_version_number, 0);
85
+ rb_define_module_function(rb_mArchive, "version_string", rb_libarchive_s_version_string, 0);
86
+
87
+ rb_eArchiveError = rb_define_class_under(rb_mArchive, "Error", rb_eStandardError);
88
+
89
+ Init_libarchive_reader();
90
+ Init_libarchive_writer();
91
+ Init_libarchive_archive();
92
+ Init_libarchive_entry();
93
+ }
94
+ #include "libarchive_internal.h"
95
+
96
+ extern VALUE rb_cArchiveReader;
97
+ extern VALUE rb_cArchiveWriter;
98
+ extern VALUE rb_eArchiveError;
99
+
100
+ static void rb_libarchive_archive_free(struct rb_libarchive_archive_container *p) {
101
+ xfree(p);
102
+ }
103
+
104
+ static void rb_libarchive_archive_mark(struct rb_libarchive_archive_container *p) {
105
+ rb_gc_mark(p->memory);
106
+ }
107
+
108
+ VALUE rb_libarchive_archive_alloc(VALUE klass) {
109
+ struct rb_libarchive_archive_container *p = ALLOC(struct rb_libarchive_archive_container);
110
+ p->ar = NULL;
111
+ p->eof = 0;
112
+ p->memory = Qnil;
113
+ return Data_Wrap_Struct(klass, rb_libarchive_archive_mark, rb_libarchive_archive_free, p);
114
+ }
115
+
116
+ /* */
117
+ static VALUE rb_libarchive_archive_position_compressed(VALUE self) {
118
+ struct rb_libarchive_archive_container *p;
119
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
120
+ Check_Archive(p);
121
+ return LONG2NUM(archive_position_compressed(p->ar));
122
+ }
123
+
124
+ /* */
125
+ static VALUE rb_libarchive_archive_position_uncompressed(VALUE self) {
126
+ struct rb_libarchive_archive_container *p;
127
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
128
+ Check_Archive(p);
129
+ return LONG2NUM(archive_position_uncompressed(p->ar));
130
+ }
131
+
132
+ /* */
133
+ static VALUE rb_libarchive_archive_compression_name(VALUE self) {
134
+ struct rb_libarchive_archive_container *p;
135
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
136
+ Check_Archive(p);
137
+ return rb_str_new2(archive_compression_name(p->ar));
138
+ }
139
+
140
+ /* */
141
+ static VALUE rb_libarchive_archive_compression(VALUE self) {
142
+ struct rb_libarchive_archive_container *p;
143
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
144
+ Check_Archive(p);
145
+ return INT2NUM(archive_compression(p->ar));
146
+ }
147
+
148
+ /* */
149
+ static VALUE rb_libarchive_archive_format_name(VALUE self) {
150
+ struct rb_libarchive_archive_container *p;
151
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
152
+ Check_Archive(p);
153
+ return rb_str_new2(archive_format_name(p->ar));
154
+ }
155
+
156
+ /* */
157
+ static VALUE rb_libarchive_archive_format(VALUE self) {
158
+ struct rb_libarchive_archive_container *p;
159
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
160
+ Check_Archive(p);
161
+ return NUM2INT(archive_format(p->ar));
162
+ }
163
+
164
+ void Init_libarchive_archive() {
165
+ rb_define_method(rb_cArchiveReader, "position_compressed", rb_libarchive_archive_position_compressed, 0);
166
+ rb_define_method(rb_cArchiveWriter, "position_compressed", rb_libarchive_archive_position_compressed, 0);
167
+ rb_define_method(rb_cArchiveReader, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
168
+ rb_define_method(rb_cArchiveWriter, "position_uncompressed", rb_libarchive_archive_position_uncompressed, 0);
169
+ rb_define_method(rb_cArchiveReader, "compression_name", rb_libarchive_archive_compression_name, 0);
170
+ rb_define_method(rb_cArchiveWriter, "compression_name", rb_libarchive_archive_compression_name, 0);
171
+ rb_define_method(rb_cArchiveReader, "compression", rb_libarchive_archive_compression, 0);
172
+ rb_define_method(rb_cArchiveWriter, "compression", rb_libarchive_archive_compression, 0);
173
+ rb_define_method(rb_cArchiveReader, "format_name", rb_libarchive_archive_format_name, 0);
174
+ rb_define_method(rb_cArchiveWriter, "format_name", rb_libarchive_archive_format_name, 0);
175
+ rb_define_method(rb_cArchiveReader, "format", rb_libarchive_archive_format, 0);
176
+ rb_define_method(rb_cArchiveWriter, "format", rb_libarchive_archive_format, 0);
177
+ }
178
+ #include "libarchive_internal.h"
179
+
180
+ extern VALUE rb_mArchive;
181
+ VALUE rb_cArchiveEntry;
182
+ extern VALUE rb_eArchiveError;
183
+
184
+ static void rb_libarchive_entry_free(struct rb_libarchive_entry_container *p) {
185
+ xfree(p);
186
+ }
187
+
188
+ static VALUE rb_libarchive_entry_alloc(VALUE klass) {
189
+ struct rb_libarchive_entry_container *p = ALLOC(struct rb_libarchive_entry_container);
190
+ p->ae = NULL;
191
+ p->must_close = 1;
192
+ return Data_Wrap_Struct(klass, 0, rb_libarchive_entry_free, p);
193
+ }
194
+
195
+ /* */
196
+ VALUE rb_libarchive_entry_close(VALUE self) {
197
+ struct rb_libarchive_entry_container *p;
198
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
199
+ Check_Entry(p);
200
+
201
+ if (!p->must_close) {
202
+ rb_raise(rb_eArchiveError, "Close entry failed: It is not necessary to close");
203
+ }
204
+
205
+ archive_entry_free(p->ae);
206
+ p->ae = NULL;
207
+ return Qnil;
208
+ }
209
+
210
+ VALUE rb_libarchive_entry_new(struct archive_entry *ae, int must_close) {
211
+ VALUE entry;
212
+ struct rb_libarchive_entry_container *p;
213
+ entry = rb_funcall(rb_cArchiveEntry, rb_intern("new"), 0);
214
+ Data_Get_Struct(entry, struct rb_libarchive_entry_container, p);
215
+ p->ae = ae;
216
+ p->must_close = must_close;
217
+ return entry;
218
+ }
219
+
220
+ /* */
221
+ static VALUE rb_libarchive_entry_atime(VALUE self) {
222
+ struct rb_libarchive_entry_container *p;
223
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
224
+ Check_Entry(p);
225
+ return LONG2TIME((long) archive_entry_atime(p->ae));
226
+ }
227
+
228
+ /* */
229
+ static VALUE rb_libarchive_entry_atime_nsec(VALUE self) {
230
+ struct rb_libarchive_entry_container *p;
231
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
232
+ Check_Entry(p);
233
+ return LONG2NUM(archive_entry_atime_nsec(p->ae));
234
+ }
235
+
236
+ /* */
237
+ static VALUE rb_libarchive_entry_atime_is_set(VALUE self) {
238
+ struct rb_libarchive_entry_container *p;
239
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
240
+ Check_Entry(p);
241
+ return archive_entry_atime_is_set(p->ae) ? Qtrue : Qfalse;
242
+ }
243
+
244
+ /* */
245
+ static VALUE rb_libarchive_entry_birthtime(VALUE self) {
246
+ struct rb_libarchive_entry_container *p;
247
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
248
+ Check_Entry(p);
249
+ return LONG2TIME((long) archive_entry_birthtime(p->ae));
250
+ }
251
+
252
+ /* */
253
+ static VALUE rb_libarchive_entry_birthtime_nsec(VALUE self) {
254
+ struct rb_libarchive_entry_container *p;
255
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
256
+ Check_Entry(p);
257
+ return LONG2NUM(archive_entry_birthtime_nsec(p->ae));
258
+ }
259
+
260
+ /* */
261
+ static VALUE rb_libarchive_entry_birthtime_is_set(VALUE self) {
262
+ struct rb_libarchive_entry_container *p;
263
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
264
+ Check_Entry(p);
265
+ return archive_entry_birthtime_is_set(p->ae) ? Qtrue : Qfalse;
266
+ }
267
+
268
+ /* */
269
+ static VALUE rb_libarchive_entry_ctime(VALUE self) {
270
+ struct rb_libarchive_entry_container *p;
271
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
272
+ Check_Entry(p);
273
+ return LONG2TIME((long) archive_entry_ctime(p->ae));
274
+ }
275
+
276
+ /* */
277
+ static VALUE rb_libarchive_entry_ctime_nsec(VALUE self) {
278
+ struct rb_libarchive_entry_container *p;
279
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
280
+ Check_Entry(p);
281
+ return LONG2NUM(archive_entry_ctime_nsec(p->ae));
282
+ }
283
+
284
+ /* */
285
+ static VALUE rb_libarchive_entry_ctime_is_set(VALUE self) {
286
+ struct rb_libarchive_entry_container *p;
287
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
288
+ Check_Entry(p);
289
+ return archive_entry_ctime_is_set(p->ae) ? Qtrue : Qfalse;
290
+ }
291
+
292
+ /* */
293
+ static VALUE rb_libarchive_entry_dev(VALUE self) {
294
+ struct rb_libarchive_entry_container *p;
295
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
296
+ Check_Entry(p);
297
+ return LONG2NUM(archive_entry_dev(p->ae));
298
+ }
299
+
300
+ /* */
301
+ static VALUE rb_libarchive_entry_devmajor(VALUE self) {
302
+ struct rb_libarchive_entry_container *p;
303
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
304
+ Check_Entry(p);
305
+ return LONG2NUM(archive_entry_devmajor(p->ae));
306
+ }
307
+
308
+ /* */
309
+ static VALUE rb_libarchive_entry_devminor(VALUE self) {
310
+ struct rb_libarchive_entry_container *p;
311
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
312
+ Check_Entry(p);
313
+ return LONG2NUM(archive_entry_devminor(p->ae));
314
+ }
315
+
316
+ /* */
317
+ static VALUE rb_libarchive_entry_filetype(VALUE self) {
318
+ struct rb_libarchive_entry_container *p;
319
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
320
+ Check_Entry(p);
321
+ return INT2NUM(archive_entry_filetype(p->ae));
322
+ }
323
+
324
+ /* */
325
+ static VALUE rb_libarchive_entry_is_directory(VALUE self) {
326
+ struct rb_libarchive_entry_container *p;
327
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
328
+ Check_Entry(p);
329
+ return S_ISDIR(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
330
+ }
331
+
332
+ /* */
333
+ static VALUE rb_libarchive_entry_is_character_special(VALUE self) {
334
+ struct rb_libarchive_entry_container *p;
335
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
336
+ Check_Entry(p);
337
+ return S_ISCHR(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
338
+ }
339
+
340
+ /* */
341
+ static VALUE rb_libarchive_entry_is_block_special(VALUE self) {
342
+ struct rb_libarchive_entry_container *p;
343
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
344
+ Check_Entry(p);
345
+ return S_ISBLK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
346
+ }
347
+
348
+ /* */
349
+ static VALUE rb_libarchive_entry_is_regular(VALUE self) {
350
+ struct rb_libarchive_entry_container *p;
351
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
352
+ Check_Entry(p);
353
+ return S_ISREG(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
354
+ }
355
+
356
+ /* */
357
+ static VALUE rb_libarchive_entry_is_symbolic_link(VALUE self) {
358
+ struct rb_libarchive_entry_container *p;
359
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
360
+ Check_Entry(p);
361
+ return S_ISLNK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
362
+ }
363
+
364
+ /* */
365
+ static VALUE rb_libarchive_entry_is_socket(VALUE self) {
366
+ struct rb_libarchive_entry_container *p;
367
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
368
+ Check_Entry(p);
369
+ return S_ISSOCK(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
370
+ }
371
+
372
+ /* */
373
+ static VALUE rb_libarchive_entry_is_fifo(VALUE self) {
374
+ struct rb_libarchive_entry_container *p;
375
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
376
+ Check_Entry(p);
377
+ return S_ISFIFO(archive_entry_filetype(p->ae)) ? Qtrue : Qfalse;
378
+ }
379
+
380
+ /* */
381
+ static VALUE rb_libarchive_entry_fflags(VALUE self) {
382
+ struct rb_libarchive_entry_container *p;
383
+ long set, clear;
384
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
385
+ Check_Entry(p);
386
+ archive_entry_fflags(p->ae, &set, &clear);
387
+ return rb_ary_new3(2, LONG2NUM(set), LONG2NUM(clear));
388
+ }
389
+
390
+ /* */
391
+ static VALUE rb_libarchive_entry_fflags_text(VALUE self) {
392
+ struct rb_libarchive_entry_container *p;
393
+ const char *fflags_text;
394
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
395
+ Check_Entry(p);
396
+ fflags_text = archive_entry_fflags_text(p->ae);
397
+ return (fflags_text != NULL) ? rb_str_new2(fflags_text) : Qnil;
398
+ }
399
+
400
+ /* */
401
+ static VALUE rb_libarchive_entry_gid(VALUE self) {
402
+ struct rb_libarchive_entry_container *p;
403
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
404
+ Check_Entry(p);
405
+ return LONG2NUM(archive_entry_gid(p->ae));
406
+ }
407
+
408
+ /* */
409
+ static VALUE rb_libarchive_entry_gname(VALUE self) {
410
+ struct rb_libarchive_entry_container *p;
411
+ const char *gname;
412
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
413
+ Check_Entry(p);
414
+ gname = archive_entry_gname(p->ae);
415
+ return (gname != NULL) ? rb_str_new2(gname) : Qnil;
416
+ }
417
+
418
+ /* */
419
+ static VALUE rb_libarchive_entry_hardlink(VALUE self) {
420
+ struct rb_libarchive_entry_container *p;
421
+ const char *hardlink;
422
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
423
+ Check_Entry(p);
424
+ hardlink = archive_entry_hardlink(p->ae);
425
+ return (hardlink != NULL) ? rb_str_new2(hardlink) : Qnil;
426
+ }
427
+
428
+ /* */
429
+ static VALUE rb_libarchive_entry_ino(VALUE self) {
430
+ struct rb_libarchive_entry_container *p;
431
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
432
+ return LONG2NUM(archive_entry_ino(p->ae));
433
+ }
434
+
435
+ /* */
436
+ static VALUE rb_libarchive_entry_mode(VALUE self) {
437
+ struct rb_libarchive_entry_container *p;
438
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
439
+ return LONG2NUM(archive_entry_mode(p->ae));
440
+ }
441
+
442
+ /* */
443
+ static VALUE rb_libarchive_entry_mtime(VALUE self) {
444
+ struct rb_libarchive_entry_container *p;
445
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
446
+ Check_Entry(p);
447
+ return LONG2TIME((long) archive_entry_mtime(p->ae));
448
+ }
449
+
450
+ /* */
451
+ static VALUE rb_libarchive_entry_mtime_nsec(VALUE self) {
452
+ struct rb_libarchive_entry_container *p;
453
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
454
+ Check_Entry(p);
455
+ return LONG2NUM(archive_entry_mtime_nsec(p->ae));
456
+ }
457
+
458
+ /* */
459
+ static VALUE rb_libarchive_entry_mtime_is_set(VALUE self) {
460
+ struct rb_libarchive_entry_container *p;
461
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
462
+ Check_Entry(p);
463
+ return archive_entry_mtime_is_set(p->ae) ? Qtrue : Qfalse;
464
+ }
465
+
466
+ /* */
467
+ static VALUE rb_libarchive_entry_nlink(VALUE self) {
468
+ struct rb_libarchive_entry_container *p;
469
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
470
+ Check_Entry(p);
471
+ return LONG2NUM(archive_entry_nlink(p->ae));
472
+ }
473
+
474
+ /* */
475
+ static VALUE rb_libarchive_entry_pathname(VALUE self) {
476
+ struct rb_libarchive_entry_container *p;
477
+ const char *pathname;
478
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
479
+ Check_Entry(p);
480
+ pathname = archive_entry_pathname(p->ae);
481
+ return (pathname != NULL) ? rb_str_new2(pathname) : Qnil;
482
+ }
483
+
484
+ /* */
485
+ static VALUE rb_libarchive_entry_rdev(VALUE self) {
486
+ struct rb_libarchive_entry_container *p;
487
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
488
+ Check_Entry(p);
489
+ return LONG2NUM(archive_entry_rdev(p->ae));
490
+ }
491
+
492
+ /* */
493
+ static VALUE rb_libarchive_entry_rdevmajor(VALUE self) {
494
+ struct rb_libarchive_entry_container *p;
495
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
496
+ Check_Entry(p);
497
+ return LONG2NUM(archive_entry_rdevmajor(p->ae));
498
+ }
499
+
500
+ /* */
501
+ static VALUE rb_libarchive_entry_rdevminor(VALUE self) {
502
+ struct rb_libarchive_entry_container *p;
503
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
504
+ Check_Entry(p);
505
+ return LONG2NUM(archive_entry_rdevminor(p->ae));
506
+ }
507
+
508
+ #if ARCHIVE_VERSION_NUMBER >= 2005003
509
+ /* */
510
+ static VALUE rb_libarchive_entry_sourcepath(VALUE self) {
511
+ struct rb_libarchive_entry_container *p;
512
+ const char *sourcepath;
513
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
514
+ Check_Entry(p);
515
+ sourcepath = archive_entry_sourcepath(p->ae);
516
+ return (sourcepath != NULL) ? rb_str_new2(sourcepath) : Qnil;
517
+ }
518
+ #endif
519
+
520
+ /* */
521
+ static VALUE rb_libarchive_entry_size(VALUE self) {
522
+ struct rb_libarchive_entry_container *p;
523
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
524
+ Check_Entry(p);
525
+ return LONG2NUM(archive_entry_size(p->ae));
526
+ }
527
+
528
+ /* */
529
+ static VALUE rb_libarchive_entry_size_is_set(VALUE self) {
530
+ struct rb_libarchive_entry_container *p;
531
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
532
+ Check_Entry(p);
533
+ return archive_entry_size_is_set(p->ae) ? Qtrue : Qfalse;
534
+ }
535
+
536
+ #if ARCHIVE_VERSION_NUMBER >= 2003002
537
+ /* */
538
+ static VALUE rb_libarchive_entry_strmode(VALUE self) {
539
+ struct rb_libarchive_entry_container *p;
540
+ const char *strmode;
541
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
542
+ Check_Entry(p);
543
+ strmode = archive_entry_strmode(p->ae);
544
+ return (strmode != NULL) ? rb_str_new2(strmode) : Qnil;
545
+ }
546
+ #endif
547
+
548
+ /* */
549
+ static VALUE rb_libarchive_entry_symlink(VALUE self) {
550
+ struct rb_libarchive_entry_container *p;
551
+ const char *symlink;
552
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
553
+ Check_Entry(p);
554
+ symlink = archive_entry_symlink(p->ae);
555
+ return (symlink != NULL) ? rb_str_new2(symlink) : Qnil;
556
+ }
557
+
558
+ /* */
559
+ static VALUE rb_libarchive_entry_uid(VALUE self) {
560
+ struct rb_libarchive_entry_container *p;
561
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
562
+ Check_Entry(p);
563
+ return LONG2NUM(archive_entry_uid(p->ae));
564
+ }
565
+
566
+ /* */
567
+ static VALUE rb_libarchive_entry_uname(VALUE self) {
568
+ struct rb_libarchive_entry_container *p;
569
+ const char *uname;
570
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
571
+ Check_Entry(p);
572
+ uname = archive_entry_uname(p->ae);
573
+ return (uname != NULL) ? rb_str_new2(uname) : Qnil;
574
+ }
575
+
576
+ /* */
577
+ static VALUE rb_libarchive_entry_set_atime(VALUE self, VALUE v_time) {
578
+ struct rb_libarchive_entry_container *p;
579
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
580
+ Check_Entry(p);
581
+ Check_Class(v_time, rb_cTime);
582
+ archive_entry_set_atime(p->ae, TIME2LONG(v_time), 0);
583
+ return Qnil;
584
+ }
585
+
586
+ /* */
587
+ static VALUE rb_libarchive_entry_set_atime2(VALUE self, VALUE v_time, VALUE v_ns) {
588
+ struct rb_libarchive_entry_container *p;
589
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
590
+ Check_Entry(p);
591
+ Check_Class(v_time, rb_cTime);
592
+ Check_Type(v_ns, T_FIXNUM);
593
+ archive_entry_set_atime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
594
+ return Qnil;
595
+ }
596
+
597
+ /* */
598
+ static VALUE rb_libarchive_entry_unset_atime(VALUE self) {
599
+ struct rb_libarchive_entry_container *p;
600
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
601
+ Check_Entry(p);
602
+ archive_entry_unset_atime(p->ae);
603
+ return Qnil;
604
+ }
605
+
606
+ /* */
607
+ static VALUE rb_libarchive_entry_set_birthtime(VALUE self, VALUE v_time) {
608
+ struct rb_libarchive_entry_container *p;
609
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
610
+ Check_Entry(p);
611
+ Check_Class(v_time, rb_cTime);
612
+ archive_entry_set_birthtime(p->ae, TIME2LONG(v_time), 0);
613
+ return Qnil;
614
+ }
615
+
616
+ /* */
617
+ static VALUE rb_libarchive_entry_set_birthtime2(VALUE self, VALUE v_time, VALUE v_ns) {
618
+ struct rb_libarchive_entry_container *p;
619
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
620
+ Check_Entry(p);
621
+ Check_Class(v_time, rb_cTime);
622
+ Check_Type(v_ns, T_FIXNUM);
623
+ archive_entry_set_birthtime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
624
+ return Qnil;
625
+ }
626
+
627
+ /* */
628
+ static VALUE rb_libarchive_entry_unset_birthtime(VALUE self) {
629
+ struct rb_libarchive_entry_container *p;
630
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
631
+ Check_Entry(p);
632
+ archive_entry_unset_birthtime(p->ae);
633
+ return Qnil;
634
+ }
635
+
636
+ /* */
637
+ static VALUE rb_libarchive_entry_set_ctime(VALUE self, VALUE v_time) {
638
+ struct rb_libarchive_entry_container *p;
639
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
640
+ Check_Entry(p);
641
+ Check_Class(v_time, rb_cTime);
642
+ archive_entry_set_ctime(p->ae, TIME2LONG(v_time), 0);
643
+ return Qnil;
644
+ }
645
+
646
+ /* */
647
+ static VALUE rb_libarchive_entry_set_ctime2(VALUE self, VALUE v_time, VALUE v_ns) {
648
+ struct rb_libarchive_entry_container *p;
649
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
650
+ Check_Entry(p);
651
+ Check_Class(v_time, rb_cTime);
652
+ Check_Type(v_ns, T_FIXNUM);
653
+ archive_entry_set_ctime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
654
+ return Qnil;
655
+ }
656
+
657
+ /* */
658
+ static VALUE rb_libarchive_entry_unset_ctime(VALUE self) {
659
+ struct rb_libarchive_entry_container *p;
660
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
661
+ Check_Entry(p);
662
+ archive_entry_unset_ctime(p->ae);
663
+ return Qnil;
664
+ }
665
+
666
+ /* */
667
+ static VALUE rb_libarchive_entry_set_dev(VALUE self, VALUE v_dev) {
668
+ struct rb_libarchive_entry_container *p;
669
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
670
+ Check_Entry(p);
671
+ Check_Type(v_dev, T_FIXNUM);
672
+ archive_entry_set_dev(p->ae, NUM2LONG(v_dev));
673
+ return Qnil;
674
+ }
675
+
676
+ /* */
677
+ static VALUE rb_libarchive_entry_set_devmajor(VALUE self, VALUE v_dev) {
678
+ struct rb_libarchive_entry_container *p;
679
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
680
+ Check_Entry(p);
681
+ Check_Type(v_dev, T_FIXNUM);
682
+ archive_entry_set_devmajor(p->ae, NUM2LONG(v_dev));
683
+ return Qnil;
684
+ }
685
+
686
+ /* */
687
+ static VALUE rb_libarchive_entry_set_devminor(VALUE self, VALUE v_dev) {
688
+ struct rb_libarchive_entry_container *p;
689
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
690
+ Check_Entry(p);
691
+ Check_Type(v_dev, T_FIXNUM);
692
+ archive_entry_set_devminor(p->ae, NUM2LONG(v_dev));
693
+ return Qnil;
694
+ }
695
+
696
+ /* */
697
+ static VALUE rb_libarchive_entry_set_filetype(VALUE self, VALUE v_type) {
698
+ struct rb_libarchive_entry_container *p;
699
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
700
+ Check_Entry(p);
701
+ Check_Type(v_type, T_FIXNUM);
702
+ archive_entry_set_filetype(p->ae, NUM2LONG(v_type));
703
+ return Qnil;
704
+ }
705
+
706
+ /* */
707
+ static VALUE rb_libarchive_entry_set_fflags(VALUE self, VALUE v_set, VALUE v_clear) {
708
+ struct rb_libarchive_entry_container *p;
709
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
710
+ Check_Entry(p);
711
+ Check_Type(v_set, T_FIXNUM);
712
+ Check_Type(v_clear, T_FIXNUM);
713
+ archive_entry_set_fflags(p->ae, (unsigned long) NUM2LONG(v_set), (unsigned long) NUM2LONG(v_clear));
714
+ return Qnil;
715
+ }
716
+
717
+ /* */
718
+ static VALUE rb_libarchive_entry_copy_fflags_text(VALUE self, VALUE v_fflags_text) {
719
+ struct rb_libarchive_entry_container *p;
720
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
721
+ Check_Entry(p);
722
+ Check_Type(v_fflags_text, T_STRING);
723
+ archive_entry_copy_fflags_text(p->ae, RSTRING_PTR(v_fflags_text));
724
+ return Qnil;
725
+ }
726
+
727
+ /* */
728
+ static VALUE rb_libarchive_entry_set_gid(VALUE self, VALUE v_gid) {
729
+ struct rb_libarchive_entry_container *p;
730
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
731
+ Check_Entry(p);
732
+ Check_Type(v_gid, T_FIXNUM);
733
+ archive_entry_set_gid(p->ae, NUM2INT(v_gid));
734
+ return Qnil;
735
+ }
736
+
737
+ /* */
738
+ static VALUE rb_libarchive_entry_set_gname(VALUE self, VALUE v_gname) {
739
+ struct rb_libarchive_entry_container *p;
740
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
741
+ Check_Entry(p);
742
+ Check_Type(v_gname, T_STRING);
743
+ archive_entry_set_gname(p->ae, RSTRING_PTR(v_gname));
744
+ return Qnil;
745
+ }
746
+
747
+ /* */
748
+ static VALUE rb_libarchive_entry_copy_gname(VALUE self, VALUE v_gname) {
749
+ struct rb_libarchive_entry_container *p;
750
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
751
+ Check_Entry(p);
752
+ Check_Type(v_gname, T_STRING);
753
+ archive_entry_copy_gname(p->ae, RSTRING_PTR(v_gname));
754
+ return Qnil;
755
+ }
756
+
757
+ /* */
758
+ static VALUE rb_libarchive_entry_set_hardlink(VALUE self, VALUE v_hardlink) {
759
+ struct rb_libarchive_entry_container *p;
760
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
761
+ Check_Entry(p);
762
+ Check_Type(v_hardlink, T_STRING);
763
+ archive_entry_set_hardlink(p->ae, RSTRING_PTR(v_hardlink));
764
+ return Qnil;
765
+ }
766
+
767
+ /* */
768
+ static VALUE rb_libarchive_entry_copy_hardlink(VALUE self, VALUE v_hardlink) {
769
+ struct rb_libarchive_entry_container *p;
770
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
771
+ Check_Entry(p);
772
+ Check_Type(v_hardlink, T_STRING);
773
+ archive_entry_copy_hardlink(p->ae, RSTRING_PTR(v_hardlink));
774
+ return Qnil;
775
+ }
776
+
777
+ /* */
778
+ static VALUE rb_libarchive_entry_set_ino(VALUE self, VALUE v_ino) {
779
+ struct rb_libarchive_entry_container *p;
780
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
781
+ Check_Entry(p);
782
+ Check_Type(v_ino, T_FIXNUM);
783
+ archive_entry_set_ino(p->ae, (unsigned long) NUM2LONG(v_ino));
784
+ return Qnil;
785
+ }
786
+
787
+ /* */
788
+ static VALUE rb_libarchive_entry_set_link(VALUE self, VALUE v_link) {
789
+ struct rb_libarchive_entry_container *p;
790
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
791
+ Check_Entry(p);
792
+ Check_Type(v_link, T_STRING);
793
+ archive_entry_set_link(p->ae, RSTRING_PTR(v_link));
794
+ return Qnil;
795
+ }
796
+
797
+ /* */
798
+ static VALUE rb_libarchive_entry_copy_link(VALUE self, VALUE v_link) {
799
+ struct rb_libarchive_entry_container *p;
800
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
801
+ Check_Entry(p);
802
+ Check_Type(v_link, T_STRING);
803
+ archive_entry_copy_link(p->ae, RSTRING_PTR(v_link));
804
+ return Qnil;
805
+ }
806
+
807
+ /* */
808
+ static VALUE rb_libarchive_entry_set_mode(VALUE self, VALUE v_mode) {
809
+ struct rb_libarchive_entry_container *p;
810
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
811
+ Check_Entry(p);
812
+ Check_Type(v_mode, T_FIXNUM);
813
+ archive_entry_set_mode(p->ae, NUM2INT(v_mode));
814
+ return Qnil;
815
+ }
816
+
817
+ /* */
818
+ static VALUE rb_libarchive_entry_set_mtime(VALUE self, VALUE v_time) {
819
+ struct rb_libarchive_entry_container *p;
820
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
821
+ Check_Entry(p);
822
+ Check_Class(v_time, rb_cTime);
823
+ archive_entry_set_mtime(p->ae, TIME2LONG(v_time), 0);
824
+ return Qnil;
825
+ }
826
+
827
+ /* */
828
+ static VALUE rb_libarchive_entry_set_mtime2(VALUE self, VALUE v_time, VALUE v_ns) {
829
+ struct rb_libarchive_entry_container *p;
830
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
831
+ Check_Entry(p);
832
+ Check_Class(v_time, rb_cTime);
833
+ Check_Type(v_ns, T_FIXNUM);
834
+ archive_entry_set_mtime(p->ae, TIME2LONG(v_time), NUM2LONG(v_ns));
835
+ return Qnil;
836
+ }
837
+
838
+ /* */
839
+ static VALUE rb_libarchive_entry_unset_mtime(VALUE self) {
840
+ struct rb_libarchive_entry_container *p;
841
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
842
+ Check_Entry(p);
843
+ archive_entry_unset_mtime(p->ae);
844
+ return Qnil;
845
+ }
846
+
847
+ /* */
848
+ static VALUE rb_libarchive_entry_set_nlink(VALUE self, VALUE v_nlink) {
849
+ struct rb_libarchive_entry_container *p;
850
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
851
+ Check_Entry(p);
852
+ Check_Type(v_nlink, T_FIXNUM);
853
+ archive_entry_set_nlink(p->ae, NUM2LONG(v_nlink));
854
+ return Qnil;
855
+ }
856
+
857
+ /* */
858
+ static VALUE rb_libarchive_entry_set_pathname(VALUE self, VALUE v_filename) {
859
+ struct rb_libarchive_entry_container *p;
860
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
861
+ Check_Entry(p);
862
+ Check_Type(v_filename, T_STRING);
863
+ archive_entry_set_pathname(p->ae, RSTRING_PTR(v_filename));
864
+ return Qnil;
865
+ }
866
+
867
+ /* */
868
+ static VALUE rb_libarchive_entry_copy_pathname(VALUE self, VALUE v_filename) {
869
+ struct rb_libarchive_entry_container *p;
870
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
871
+ Check_Entry(p);
872
+ Check_Type(v_filename, T_STRING);
873
+ archive_entry_copy_pathname(p->ae, RSTRING_PTR(v_filename));
874
+ return Qnil;
875
+ }
876
+
877
+ /* */
878
+ static VALUE rb_libarchive_entry_set_perm(VALUE self, VALUE v_perm) {
879
+ struct rb_libarchive_entry_container *p;
880
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
881
+ Check_Entry(p);
882
+ Check_Type(v_perm, T_FIXNUM);
883
+ archive_entry_set_perm(p->ae, NUM2INT(v_perm));
884
+ return Qnil;
885
+ }
886
+
887
+ /* */
888
+ static VALUE rb_libarchive_entry_set_rdev(VALUE self, VALUE v_rdev) {
889
+ struct rb_libarchive_entry_container *p;
890
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
891
+ Check_Entry(p);
892
+ Check_Type(v_rdev, T_FIXNUM);
893
+ archive_entry_set_rdev(p->ae, NUM2LONG(v_rdev));
894
+ return Qnil;
895
+ }
896
+
897
+ /* */
898
+ static VALUE rb_libarchive_entry_set_rdevmajor(VALUE self, VALUE v_rdev) {
899
+ struct rb_libarchive_entry_container *p;
900
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
901
+ Check_Entry(p);
902
+ Check_Type(v_rdev, T_FIXNUM);
903
+ archive_entry_set_rdevmajor(p->ae, NUM2LONG(v_rdev));
904
+ return Qnil;
905
+ }
906
+
907
+ /* */
908
+ static VALUE rb_libarchive_entry_set_rdevminor(VALUE self, VALUE v_rdev) {
909
+ struct rb_libarchive_entry_container *p;
910
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
911
+ Check_Entry(p);
912
+ Check_Type(v_rdev, T_FIXNUM);
913
+ archive_entry_set_rdevminor(p->ae, NUM2LONG(v_rdev));
914
+ return Qnil;
915
+ }
916
+
917
+ /* */
918
+ static VALUE rb_libarchive_entry_set_size(VALUE self, VALUE v_size) {
919
+ struct rb_libarchive_entry_container *p;
920
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
921
+ Check_Entry(p);
922
+ Check_Type(v_size, T_FIXNUM);
923
+ archive_entry_set_size(p->ae, NUM2LONG(v_size));
924
+ return Qnil;
925
+ }
926
+
927
+ /* */
928
+ static VALUE rb_libarchive_entry_unset_size(VALUE self) {
929
+ struct rb_libarchive_entry_container *p;
930
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
931
+ Check_Entry(p);
932
+ archive_entry_unset_size(p->ae);
933
+ return Qnil;
934
+ }
935
+
936
+ #if ARCHIVE_VERSION_NUMBER >= 2005003
937
+ /* */
938
+ static VALUE rb_libarchive_entry_copy_sourcepath(VALUE self, VALUE v_sourcepath) {
939
+ struct rb_libarchive_entry_container *p;
940
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
941
+ Check_Entry(p);
942
+ Check_Type(v_sourcepath, T_STRING);
943
+ archive_entry_copy_sourcepath(p->ae, RSTRING_PTR(v_sourcepath));
944
+ return Qnil;
945
+ }
946
+ #endif
947
+
948
+ /* */
949
+ static VALUE rb_libarchive_entry_set_symlink(VALUE self, VALUE v_symlink) {
950
+ struct rb_libarchive_entry_container *p;
951
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
952
+ Check_Entry(p);
953
+ Check_Type(v_symlink, T_STRING);
954
+ archive_entry_set_symlink(p->ae, RSTRING_PTR(v_symlink));
955
+ return Qnil;
956
+ }
957
+
958
+ /* */
959
+ static VALUE rb_libarchive_entry_copy_symlink(VALUE self, VALUE v_symlink) {
960
+ struct rb_libarchive_entry_container *p;
961
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
962
+ Check_Entry(p);
963
+ Check_Type(v_symlink, T_STRING);
964
+ archive_entry_copy_symlink(p->ae, RSTRING_PTR(v_symlink));
965
+ return Qnil;
966
+ }
967
+
968
+ /* */
969
+ static VALUE rb_libarchive_entry_set_uid(VALUE self, VALUE v_uid) {
970
+ struct rb_libarchive_entry_container *p;
971
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
972
+ Check_Entry(p);
973
+ Check_Type(v_uid, T_FIXNUM);
974
+ archive_entry_set_uid(p->ae, NUM2INT(v_uid));
975
+ return Qnil;
976
+ }
977
+
978
+ /* */
979
+ static VALUE rb_libarchive_entry_set_uname(VALUE self, VALUE v_uname) {
980
+ struct rb_libarchive_entry_container *p;
981
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
982
+ Check_Entry(p);
983
+ Check_Type(v_uname, T_STRING);
984
+ archive_entry_set_uname(p->ae, RSTRING_PTR(v_uname));
985
+ return Qnil;
986
+ }
987
+
988
+ /* */
989
+ static VALUE rb_libarchive_entry_copy_uname(VALUE self, VALUE v_uname) {
990
+ struct rb_libarchive_entry_container *p;
991
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
992
+ Check_Entry(p);
993
+ Check_Type(v_uname, T_STRING);
994
+ archive_entry_copy_uname(p->ae, RSTRING_PTR(v_uname));
995
+ return Qnil;
996
+ }
997
+
998
+ /* */
999
+ static VALUE rb_libarchive_entry_copy_stat(VALUE self, VALUE v_filename) {
1000
+ struct rb_libarchive_entry_container *p;
1001
+ const char *filename;
1002
+ struct stat s;
1003
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1004
+ Check_Entry(p);
1005
+ Check_Type(v_filename, T_STRING);
1006
+ filename = RSTRING_PTR(v_filename);
1007
+
1008
+ if (stat(filename, &s) != 0) {
1009
+ rb_raise(rb_eArchiveError, "Copy stat failed: %", strerror(errno));
1010
+ }
1011
+
1012
+ archive_entry_copy_stat(p->ae, &s);
1013
+ return Qnil;
1014
+ }
1015
+
1016
+ /* */
1017
+ static VALUE rb_libarchive_entry_copy_lstat(VALUE self, VALUE v_filename) {
1018
+ struct rb_libarchive_entry_container *p;
1019
+ const char *filename;
1020
+ struct stat s;
1021
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1022
+ Check_Entry(p);
1023
+ Check_Type(v_filename, T_STRING);
1024
+ filename = RSTRING_PTR(v_filename);
1025
+
1026
+ if (lstat(filename, &s) != 0) {
1027
+ rb_raise(rb_eArchiveError, "Copy stat failed: %", strerror(errno));
1028
+ }
1029
+
1030
+ archive_entry_copy_stat(p->ae, &s);
1031
+ return Qnil;
1032
+ }
1033
+
1034
+ /* */
1035
+ static VALUE rb_libarchive_entry_xattr_clear(VALUE self) {
1036
+ struct rb_libarchive_entry_container *p;
1037
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1038
+ Check_Entry(p);
1039
+ archive_entry_xattr_clear(p->ae);
1040
+ return Qnil;
1041
+ }
1042
+
1043
+ /* */
1044
+ static VALUE rb_libarchive_entry_xattr_add_entry(VALUE self, VALUE v_name, VALUE v_value) {
1045
+ struct rb_libarchive_entry_container *p;
1046
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1047
+ Check_Entry(p);
1048
+ Check_Type(v_name, T_STRING);
1049
+ Check_Type(v_value, T_STRING);
1050
+ archive_entry_xattr_add_entry(p->ae, RSTRING_PTR(v_name), RSTRING_PTR(v_value), RSTRING_LEN(v_value));
1051
+ return Qnil;
1052
+ }
1053
+
1054
+ /* */
1055
+ static VALUE rb_libarchive_entry_xattr_count(VALUE self) {
1056
+ struct rb_libarchive_entry_container *p;
1057
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1058
+ Check_Entry(p);
1059
+ return INT2NUM(archive_entry_xattr_count(p->ae));
1060
+ }
1061
+
1062
+ /* */
1063
+ static VALUE rb_libarchive_entry_xattr_reset(VALUE self) {
1064
+ struct rb_libarchive_entry_container *p;
1065
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1066
+ Check_Entry(p);
1067
+ return INT2NUM(archive_entry_xattr_reset(p->ae));
1068
+ }
1069
+
1070
+ /* */
1071
+ static VALUE rb_libarchive_entry_xattr_next(VALUE self) {
1072
+ struct rb_libarchive_entry_container *p;
1073
+ const char *name;
1074
+ const void *value;
1075
+ size_t size;
1076
+ Data_Get_Struct(self, struct rb_libarchive_entry_container, p);
1077
+ Check_Entry(p);
1078
+
1079
+ if (archive_entry_xattr_next(p->ae, &name, &value, &size) != ARCHIVE_OK) {
1080
+ return Qnil;
1081
+ } else {
1082
+ return rb_ary_new3(3, rb_str_new2(name), rb_str_new(value, size));
1083
+ }
1084
+ }
1085
+
1086
+ void Init_libarchive_entry() {
1087
+ rb_cArchiveEntry = rb_define_class_under(rb_mArchive, "Entry", rb_cObject);
1088
+ rb_define_alloc_func(rb_cArchiveEntry, rb_libarchive_entry_alloc);
1089
+ rb_funcall(rb_cArchiveEntry, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1090
+ rb_define_method(rb_cArchiveEntry, "close", rb_libarchive_entry_close, 0);
1091
+
1092
+ rb_define_method(rb_cArchiveEntry, "atime", rb_libarchive_entry_atime, 0);
1093
+ rb_define_method(rb_cArchiveEntry, "atime_nsec", rb_libarchive_entry_atime_nsec, 0);
1094
+ rb_define_method(rb_cArchiveEntry, "atime_is_set?", rb_libarchive_entry_atime_is_set, 0);
1095
+ rb_define_method(rb_cArchiveEntry, "birthtime", rb_libarchive_entry_birthtime, 0);
1096
+ rb_define_method(rb_cArchiveEntry, "birthtime_nsec", rb_libarchive_entry_birthtime_nsec, 0);
1097
+ rb_define_method(rb_cArchiveEntry, "birthtime_is_set?", rb_libarchive_entry_birthtime_is_set, 0);
1098
+ rb_define_method(rb_cArchiveEntry, "ctime", rb_libarchive_entry_ctime, 0);
1099
+ rb_define_method(rb_cArchiveEntry, "ctime_nsec", rb_libarchive_entry_ctime_nsec, 0);
1100
+ rb_define_method(rb_cArchiveEntry, "ctime_is_set?", rb_libarchive_entry_ctime_is_set, 0);
1101
+ rb_define_method(rb_cArchiveEntry, "dev", rb_libarchive_entry_dev, 0);
1102
+ rb_define_method(rb_cArchiveEntry, "devmajor", rb_libarchive_entry_devmajor, 0);
1103
+ rb_define_method(rb_cArchiveEntry, "devminor", rb_libarchive_entry_devminor, 0);
1104
+ rb_define_method(rb_cArchiveEntry, "filetype", rb_libarchive_entry_filetype, 0);
1105
+ rb_define_method(rb_cArchiveEntry, "directory?", rb_libarchive_entry_is_directory, 0);
1106
+ rb_define_method(rb_cArchiveEntry, "character_special?", rb_libarchive_entry_is_character_special, 0);
1107
+ rb_define_method(rb_cArchiveEntry, "block_special?", rb_libarchive_entry_is_block_special, 0);
1108
+ rb_define_method(rb_cArchiveEntry, "regular?", rb_libarchive_entry_is_regular, 0);
1109
+ rb_define_method(rb_cArchiveEntry, "symbolic_link?", rb_libarchive_entry_is_symbolic_link, 0);
1110
+ rb_define_method(rb_cArchiveEntry, "socket?", rb_libarchive_entry_is_socket, 0);
1111
+ rb_define_method(rb_cArchiveEntry, "fifo?", rb_libarchive_entry_is_fifo, 0);
1112
+ rb_define_method(rb_cArchiveEntry, "fflags", rb_libarchive_entry_fflags, 0);
1113
+ rb_define_method(rb_cArchiveEntry, "fflags_text", rb_libarchive_entry_fflags_text, 0);
1114
+ rb_define_method(rb_cArchiveEntry, "gid", rb_libarchive_entry_gid, 0);
1115
+ rb_define_method(rb_cArchiveEntry, "gname", rb_libarchive_entry_gname, 0);
1116
+ rb_define_method(rb_cArchiveEntry, "hardlink", rb_libarchive_entry_hardlink, 0);
1117
+ rb_define_method(rb_cArchiveEntry, "ino", rb_libarchive_entry_ino, 0);
1118
+ rb_define_method(rb_cArchiveEntry, "mode", rb_libarchive_entry_mode, 0);
1119
+ rb_define_method(rb_cArchiveEntry, "mtime", rb_libarchive_entry_mtime, 0);
1120
+ rb_define_method(rb_cArchiveEntry, "mtime_nsec", rb_libarchive_entry_mtime_nsec, 0);
1121
+ rb_define_method(rb_cArchiveEntry, "mtime_is_set?", rb_libarchive_entry_mtime_is_set, 0);
1122
+ rb_define_method(rb_cArchiveEntry, "nlink", rb_libarchive_entry_nlink, 0);
1123
+ rb_define_method(rb_cArchiveEntry, "pathname", rb_libarchive_entry_pathname, 0);
1124
+ rb_define_method(rb_cArchiveEntry, "rdev", rb_libarchive_entry_rdev, 0);
1125
+ rb_define_method(rb_cArchiveEntry, "rdevmajor", rb_libarchive_entry_rdevmajor, 0);
1126
+ rb_define_method(rb_cArchiveEntry, "rdevminor", rb_libarchive_entry_rdevminor, 0);
1127
+ #if ARCHIVE_VERSION_NUMBER >= 2005003
1128
+ rb_define_method(rb_cArchiveEntry, "sourcepath", rb_libarchive_entry_sourcepath, 0);
1129
+ #endif
1130
+ rb_define_method(rb_cArchiveEntry, "size", rb_libarchive_entry_size, 0);
1131
+ rb_define_method(rb_cArchiveEntry, "size_is_set?", rb_libarchive_entry_size_is_set, 0);
1132
+ #if ARCHIVE_VERSION_NUMBER >= 2003002
1133
+ rb_define_method(rb_cArchiveEntry, "strmode", rb_libarchive_entry_strmode, 0);
1134
+ #endif
1135
+ rb_define_method(rb_cArchiveEntry, "symlink", rb_libarchive_entry_symlink, 0);
1136
+ rb_define_method(rb_cArchiveEntry, "uid", rb_libarchive_entry_uid, 0);
1137
+ rb_define_method(rb_cArchiveEntry, "uname", rb_libarchive_entry_uname, 0);
1138
+
1139
+ rb_define_method(rb_cArchiveEntry, "atime=", rb_libarchive_entry_set_atime, 1);
1140
+ rb_define_method(rb_cArchiveEntry, "set_atime", rb_libarchive_entry_set_atime2, 2);
1141
+ rb_define_method(rb_cArchiveEntry, "unset_atime", rb_libarchive_entry_unset_atime, 0);
1142
+ rb_define_method(rb_cArchiveEntry, "birthtimee=", rb_libarchive_entry_set_birthtime, 1);
1143
+ rb_define_method(rb_cArchiveEntry, "set_birthtime", rb_libarchive_entry_set_birthtime2, 2);
1144
+ rb_define_method(rb_cArchiveEntry, "unset_birthtime", rb_libarchive_entry_unset_birthtime, 0);
1145
+ rb_define_method(rb_cArchiveEntry, "ctime=", rb_libarchive_entry_set_ctime, 1);
1146
+ rb_define_method(rb_cArchiveEntry, "set_ctime", rb_libarchive_entry_set_ctime2, 2);
1147
+ rb_define_method(rb_cArchiveEntry, "unset_ctime", rb_libarchive_entry_unset_ctime, 0);
1148
+ rb_define_method(rb_cArchiveEntry, "dev=", rb_libarchive_entry_set_dev, 1);
1149
+ rb_define_method(rb_cArchiveEntry, "devmajor=", rb_libarchive_entry_set_devmajor, 1);
1150
+ rb_define_method(rb_cArchiveEntry, "devminor=", rb_libarchive_entry_set_devminor, 1);
1151
+ rb_define_method(rb_cArchiveEntry, "filetype=", rb_libarchive_entry_set_filetype, 1);
1152
+ rb_define_method(rb_cArchiveEntry, "set_fflags", rb_libarchive_entry_set_fflags, 2);
1153
+ rb_define_method(rb_cArchiveEntry, "copy_fflags_text", rb_libarchive_entry_copy_fflags_text, 1);
1154
+ rb_define_method(rb_cArchiveEntry, "gid=", rb_libarchive_entry_set_gid, 1);
1155
+ rb_define_method(rb_cArchiveEntry, "gname=", rb_libarchive_entry_set_gname, 1);
1156
+ rb_define_method(rb_cArchiveEntry, "copy_gname", rb_libarchive_entry_copy_gname, 1);
1157
+ rb_define_method(rb_cArchiveEntry, "hardlink=", rb_libarchive_entry_set_hardlink, 1);
1158
+ rb_define_method(rb_cArchiveEntry, "copy_hardlink", rb_libarchive_entry_copy_hardlink, 1);
1159
+ rb_define_method(rb_cArchiveEntry, "ino=", rb_libarchive_entry_set_ino, 1);
1160
+ rb_define_method(rb_cArchiveEntry, "link=", rb_libarchive_entry_set_link, 1);
1161
+ rb_define_method(rb_cArchiveEntry, "copy_link", rb_libarchive_entry_copy_link, 1);
1162
+ rb_define_method(rb_cArchiveEntry, "mode=", rb_libarchive_entry_set_mode, 1);
1163
+ rb_define_method(rb_cArchiveEntry, "mtime=", rb_libarchive_entry_set_mtime, 1);
1164
+ rb_define_method(rb_cArchiveEntry, "set_mtime", rb_libarchive_entry_set_mtime2, 2);
1165
+ rb_define_method(rb_cArchiveEntry, "unset_mtime", rb_libarchive_entry_unset_mtime, 0);
1166
+ rb_define_method(rb_cArchiveEntry, "nlink=", rb_libarchive_entry_set_nlink, 1);
1167
+ rb_define_method(rb_cArchiveEntry, "pathname=", rb_libarchive_entry_set_pathname, 1);
1168
+ rb_define_method(rb_cArchiveEntry, "copy_pathname", rb_libarchive_entry_copy_pathname, 1);
1169
+ rb_define_method(rb_cArchiveEntry, "perm=", rb_libarchive_entry_set_perm, 1);
1170
+ rb_define_method(rb_cArchiveEntry, "rdev=", rb_libarchive_entry_set_rdev, 1);
1171
+ rb_define_method(rb_cArchiveEntry, "rdevmajor=", rb_libarchive_entry_set_rdevmajor, 1);
1172
+ rb_define_method(rb_cArchiveEntry, "rdevminor=", rb_libarchive_entry_set_rdevminor, 1);
1173
+ rb_define_method(rb_cArchiveEntry, "size=", rb_libarchive_entry_set_size, 1);
1174
+ rb_define_method(rb_cArchiveEntry, "unset_size", rb_libarchive_entry_unset_size, 0);
1175
+ #if ARCHIVE_VERSION_NUMBER >= 2005003
1176
+ rb_define_method(rb_cArchiveEntry, "copy_sourcepath", rb_libarchive_entry_copy_sourcepath, 1);
1177
+ #endif
1178
+ rb_define_method(rb_cArchiveEntry, "symlink=", rb_libarchive_entry_set_symlink, 1);
1179
+ rb_define_method(rb_cArchiveEntry, "copy_symlink", rb_libarchive_entry_copy_symlink, 1);
1180
+ rb_define_method(rb_cArchiveEntry, "uid=", rb_libarchive_entry_set_uid, 1);
1181
+ rb_define_method(rb_cArchiveEntry, "uname=", rb_libarchive_entry_set_uname, 1);
1182
+ rb_define_method(rb_cArchiveEntry, "copy_uname", rb_libarchive_entry_copy_uname, 1);
1183
+
1184
+ rb_define_method(rb_cArchiveEntry, "copy_stat", rb_libarchive_entry_copy_stat, 1);
1185
+ rb_define_method(rb_cArchiveEntry, "copy_lstat", rb_libarchive_entry_copy_lstat, 1);
1186
+
1187
+ rb_define_method(rb_cArchiveEntry, "xattr_clear", rb_libarchive_entry_xattr_clear, 0);
1188
+ rb_define_method(rb_cArchiveEntry, "xattr_add_entry", rb_libarchive_entry_xattr_add_entry, 2);
1189
+ rb_define_method(rb_cArchiveEntry, "xattr_count", rb_libarchive_entry_xattr_count, 0);
1190
+ rb_define_method(rb_cArchiveEntry, "xattr_reset", rb_libarchive_entry_xattr_reset, 0);
1191
+ rb_define_method(rb_cArchiveEntry, "xattr_next", rb_libarchive_entry_xattr_next, 0);
1192
+ }
1193
+ #include "libarchive_internal.h"
1194
+
1195
+ extern VALUE rb_mArchive;
1196
+ VALUE rb_cArchiveReader;
1197
+ extern VALUE rb_eArchiveError;
1198
+ extern VALUE rb_cArchiveEntry;
1199
+
1200
+ static void rb_libarchive_reader_close0(struct rb_libarchive_archive_container *p) {
1201
+ archive_read_close(p->ar);
1202
+ archive_read_finish(p->ar);
1203
+ p->ar = NULL;
1204
+ }
1205
+
1206
+ /* */
1207
+ static VALUE rb_libarchive_reader_close(VALUE self) {
1208
+ struct rb_libarchive_archive_container *p;
1209
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1210
+ Check_Archive(p);
1211
+ rb_libarchive_reader_close0(p);
1212
+ return Qnil;
1213
+ }
1214
+
1215
+ static VALUE rb_libarchive_reader_s_open0(int (*archive_open)(struct rb_libarchive_archive_container *, void *), void *arg, int compression, int format, const char *cmd) {
1216
+ VALUE reader;
1217
+ struct rb_libarchive_archive_container *p;
1218
+ int r;
1219
+ reader = rb_funcall(rb_cArchiveReader, rb_intern("new"), 0);
1220
+ Data_Get_Struct(reader, struct rb_libarchive_archive_container, p);
1221
+
1222
+ if ((p->ar = archive_read_new()) == NULL) {
1223
+ rb_raise(rb_eArchiveError, "Open reader failed: %s", strerror(errno));
1224
+ }
1225
+
1226
+ if (cmd != NULL) {
1227
+ r = archive_read_support_compression_program(p->ar, cmd);
1228
+ } else if (compression != -1) {
1229
+ r = archive_read_support_compression(p->ar, compression);
1230
+ } else {
1231
+ r = archive_read_support_compression_all(p->ar);
1232
+ }
1233
+
1234
+ if (r != ARCHIVE_OK) {
1235
+ char error_string[BUFSIZ];
1236
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1237
+ rb_libarchive_reader_close0(p);
1238
+ rb_raise(rb_eArchiveError, "Support compression failed: %s", error_string);
1239
+ }
1240
+
1241
+ if (format != -1) {
1242
+ r = archive_read_support_format(p->ar, format);
1243
+ } else {
1244
+ r = archive_read_support_format_all(p->ar);
1245
+ }
1246
+
1247
+ if (r != ARCHIVE_OK) {
1248
+ char error_string[BUFSIZ];
1249
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1250
+ rb_libarchive_reader_close0(p);
1251
+ rb_raise(rb_eArchiveError, "Support format failed: %s", error_string);
1252
+ }
1253
+
1254
+ if (archive_open(p, arg) != ARCHIVE_OK) {
1255
+ char error_string[BUFSIZ];
1256
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1257
+ rb_libarchive_reader_close0(p);
1258
+ rb_raise(rb_eArchiveError, "Open reader failed: %s", error_string);
1259
+ }
1260
+
1261
+ if (rb_block_given_p()) {
1262
+ VALUE retval;
1263
+ int status;
1264
+ retval = rb_protect(rb_yield, reader, &status);
1265
+ rb_libarchive_reader_close0(p);
1266
+
1267
+ if (status != 0) {
1268
+ rb_jump_tag(status);
1269
+ }
1270
+
1271
+ return retval;
1272
+ } else {
1273
+ return reader;
1274
+ }
1275
+ }
1276
+
1277
+ static int rb_libarchive_reader_s_open_filename0(struct rb_libarchive_archive_container *p, void *arg) {
1278
+ const char *filename = (const char *) arg;
1279
+
1280
+ if (filename != NULL) {
1281
+ struct stat s;
1282
+
1283
+ if (stat(filename, &s) != 0) {
1284
+ archive_set_error(p->ar, -1, strerror(errno));
1285
+ return (ARCHIVE_FATAL);
1286
+ }
1287
+ }
1288
+
1289
+ return archive_read_open_filename(p->ar, filename, BLOCK_SIZE);
1290
+ }
1291
+
1292
+ /* */
1293
+ static VALUE rb_libarchive_reader_s_open_filename(int argc, VALUE *argv, VALUE self) {
1294
+ VALUE v_filename, v_compression, v_format;
1295
+ const char *filename = NULL;
1296
+ int compression = -1, format = -1;
1297
+ const char *cmd = NULL;
1298
+ rb_scan_args(argc, argv, "12", &v_filename, &v_compression, &v_format);
1299
+ Check_Type(v_filename, T_STRING);
1300
+ filename = RSTRING_PTR(v_filename);
1301
+
1302
+ if (T_STRING == TYPE(v_compression)) {
1303
+ compression = -1;
1304
+ cmd = RSTRING_PTR(v_compression);
1305
+ } else if (!NIL_P(v_compression)) {
1306
+ compression = NUM2INT(v_compression);
1307
+ }
1308
+
1309
+ if (!NIL_P(v_format)) {
1310
+ format = NUM2INT(v_format);
1311
+ }
1312
+
1313
+ return rb_libarchive_reader_s_open0(rb_libarchive_reader_s_open_filename0, (void *) filename, compression, format, cmd);
1314
+ }
1315
+
1316
+ static int rb_libarchive_reader_s_open_memory0(struct rb_libarchive_archive_container *p, void *arg) {
1317
+ VALUE v_buff = (VALUE) arg;
1318
+ return archive_read_open_memory(p->ar, RSTRING_PTR(v_buff), RSTRING_LEN(v_buff));
1319
+ }
1320
+
1321
+ /* */
1322
+ static VALUE rb_libarchive_reader_s_open_memory(int argc, VALUE *argv, VALUE self) {
1323
+ VALUE v_memory, v_compression, v_format;
1324
+ int compression = -1, format = -1;
1325
+ const char *cmd = NULL;
1326
+ rb_scan_args(argc, argv, "12", &v_memory, &v_compression, &v_format);
1327
+ Check_Type(v_memory, T_STRING);
1328
+
1329
+ if (T_STRING == TYPE(v_compression)) {
1330
+ compression = -1;
1331
+ cmd = RSTRING_PTR(v_compression);
1332
+ } else if (!NIL_P(v_compression)) {
1333
+ compression = NUM2INT(v_compression);
1334
+ }
1335
+
1336
+ if (!NIL_P(v_format)) {
1337
+ format = NUM2INT(v_format);
1338
+ }
1339
+
1340
+ return rb_libarchive_reader_s_open0(rb_libarchive_reader_s_open_memory0, (void *) v_memory, compression, format, cmd);
1341
+ }
1342
+
1343
+ /* */
1344
+ static VALUE rb_libarchive_reader_next_header(VALUE self) {
1345
+ struct rb_libarchive_archive_container *p;
1346
+ struct archive_entry *ae;
1347
+ int r;
1348
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1349
+ Check_Archive(p);
1350
+
1351
+ if (p->eof) {
1352
+ return Qnil;
1353
+ }
1354
+
1355
+ r = archive_read_next_header(p->ar, &ae);
1356
+
1357
+ if (r == ARCHIVE_EOF) {
1358
+ p->eof = 1;
1359
+ return Qnil;
1360
+ } else if (r != ARCHIVE_OK) {
1361
+ rb_raise(rb_eArchiveError, "Fetch entry failed: %s", archive_error_string(p->ar));
1362
+ }
1363
+
1364
+ return rb_libarchive_entry_new(ae, 0);
1365
+ }
1366
+
1367
+ /* */
1368
+ static VALUE rb_libarchive_reader_header_position(VALUE self) {
1369
+ struct rb_libarchive_archive_container *p;
1370
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1371
+ Check_Archive(p);
1372
+ return LONG2NUM((long) archive_read_header_position(p->ar));
1373
+ }
1374
+
1375
+ /* */
1376
+ static VALUE rb_libarchive_reader_read_data(int argc, VALUE *argv, VALUE self) {
1377
+ VALUE v_size;
1378
+ struct rb_libarchive_archive_container *p;
1379
+ char *buff;
1380
+ size_t size = DATA_BUFFER_SIZE;
1381
+ ssize_t n;
1382
+ rb_scan_args(argc, argv, "01", &v_size);
1383
+
1384
+ if (!NIL_P(v_size)) {
1385
+ size = NUM2INT(v_size);
1386
+ }
1387
+
1388
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1389
+ Check_Archive(p);
1390
+
1391
+ if (p->eof) {
1392
+ return Qnil;
1393
+ }
1394
+
1395
+ if (rb_block_given_p()) {
1396
+ ssize_t len = 0;
1397
+ int status = 0;
1398
+ buff = xmalloc(size);
1399
+
1400
+ while ((n = archive_read_data(p->ar, buff, size)) > 0) {
1401
+ rb_protect(rb_yield, rb_str_new(buff, n), &status);
1402
+
1403
+ if (status != 0) {
1404
+ break;
1405
+ }
1406
+
1407
+ len += n;
1408
+ }
1409
+
1410
+ xfree(buff);
1411
+
1412
+ if (status != 0) {
1413
+ rb_jump_tag(status);
1414
+ }
1415
+
1416
+ if (n < 0) {
1417
+ rb_raise(rb_eArchiveError, "Read data failed: %s", archive_error_string(p->ar));
1418
+ }
1419
+
1420
+ return LONG2NUM(len);
1421
+ } else {
1422
+ VALUE retval = rb_str_new("", 0);
1423
+ buff = xmalloc(size);
1424
+
1425
+ while ((n = archive_read_data(p->ar, buff, size)) > 0) {
1426
+ rb_str_cat(retval, buff, n);
1427
+ }
1428
+
1429
+ xfree(buff);
1430
+
1431
+ if (n < 0) {
1432
+ rb_raise(rb_eArchiveError, "Read data failed: %s", archive_error_string(p->ar));
1433
+ }
1434
+
1435
+ return retval;
1436
+ }
1437
+ }
1438
+
1439
+ /* */
1440
+ static VALUE rb_libarchive_reader_save_data(int argc, VALUE *argv, VALUE self) {
1441
+ VALUE v_filename, v_flags;
1442
+ struct rb_libarchive_archive_container *p;
1443
+ const char *filename;
1444
+ int flags, fd, r;
1445
+ rb_scan_args(argc, argv, "11", &v_filename, &v_flags);
1446
+ Check_Type(v_filename, T_STRING);
1447
+ filename = RSTRING_PTR(v_filename);
1448
+
1449
+ if (!NIL_P(v_flags)) {
1450
+ flags = ((O_WRONLY | NUM2INT(v_flags)) & O_FLAGS);
1451
+ } else {
1452
+ flags = (O_WRONLY | O_CREAT | O_EXCL
1453
+ #ifdef O_BINARY
1454
+ | O_BINARY
1455
+ #endif
1456
+ );
1457
+ }
1458
+
1459
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1460
+ Check_Archive(p);
1461
+
1462
+ if ((fd = open(filename, flags)) == -1) {
1463
+ rb_raise(rb_eArchiveError, "Save data failed: %s", strerror(errno));
1464
+ }
1465
+
1466
+ r = archive_read_data_into_fd(p->ar, fd);
1467
+ _close(fd);
1468
+
1469
+ if (r != ARCHIVE_OK) {
1470
+ rb_raise(rb_eArchiveError, "Save data failed: %s", archive_error_string(p->ar));
1471
+ }
1472
+
1473
+ return Qnil;
1474
+ }
1475
+
1476
+ /* */
1477
+ static VALUE rb_libarchive_reader_extract(int argc, VALUE *argv, VALUE self) {
1478
+ VALUE v_entry, v_flags;
1479
+ struct rb_libarchive_archive_container *pa;
1480
+ struct rb_libarchive_entry_container *pae;
1481
+ int flags = 0;
1482
+ rb_scan_args(argc, argv, "11", &v_entry, &v_flags);
1483
+ Check_Class(v_entry, rb_cArchiveEntry);
1484
+
1485
+ if (!NIL_P(v_flags)) {
1486
+ flags = (NUM2INT(v_flags) & EXTRACT_FLAGS);
1487
+ }
1488
+
1489
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, pa);
1490
+ Check_Archive(pa);
1491
+
1492
+ if (pa->eof) {
1493
+ rb_raise(rb_eArchiveError, "Extract archive failed: It has already reached EOF");
1494
+ }
1495
+
1496
+ Data_Get_Struct(v_entry, struct rb_libarchive_entry_container, pae);
1497
+ Check_Entry(pae);
1498
+
1499
+ if (archive_read_extract(pa->ar, pae->ae, flags) != ARCHIVE_OK) {
1500
+ rb_raise(rb_eArchiveError, "Extract archive failed: %s", archive_error_string(pa->ar));
1501
+ }
1502
+
1503
+ return Qnil;
1504
+ }
1505
+
1506
+ void Init_libarchive_reader() {
1507
+ rb_cArchiveReader = rb_define_class_under(rb_mArchive, "Reader", rb_cObject);
1508
+ rb_define_alloc_func(rb_cArchiveReader, rb_libarchive_archive_alloc);
1509
+ rb_funcall(rb_cArchiveReader, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1510
+ rb_define_singleton_method(rb_cArchiveReader, "open_filename", rb_libarchive_reader_s_open_filename, -1);
1511
+ rb_define_module_function(rb_mArchive, "read_open_filename", rb_libarchive_reader_s_open_filename, -1);
1512
+ rb_define_singleton_method(rb_cArchiveReader, "open_memory", rb_libarchive_reader_s_open_memory, -1);
1513
+ rb_define_module_function(rb_mArchive, "read_open_memory", rb_libarchive_reader_s_open_memory, -1);
1514
+ rb_define_method(rb_cArchiveReader, "close", rb_libarchive_reader_close, 0);
1515
+ rb_define_method(rb_cArchiveReader, "next_header", rb_libarchive_reader_next_header, 0);
1516
+ rb_define_method(rb_cArchiveReader, "header_position", rb_libarchive_reader_header_position, 0);
1517
+ rb_define_method(rb_cArchiveReader, "read_data", rb_libarchive_reader_read_data, -1);
1518
+ rb_define_method(rb_cArchiveReader, "save_data", rb_libarchive_reader_save_data, -1);
1519
+ rb_define_method(rb_cArchiveReader, "extract", rb_libarchive_reader_extract, -1);
1520
+ }
1521
+ #include "libarchive_internal.h"
1522
+
1523
+ extern VALUE rb_mArchive;
1524
+ VALUE rb_cArchiveWriter;
1525
+ extern VALUE rb_eArchiveError;
1526
+ extern VALUE rb_cArchiveEntry;
1527
+
1528
+ static void rb_libarchive_writer_close0(struct rb_libarchive_archive_container *p) {
1529
+ archive_write_close(p->ar);
1530
+ archive_write_finish(p->ar);
1531
+ p->ar = NULL;
1532
+ }
1533
+
1534
+ /* */
1535
+ static VALUE rb_libarchive_writer_close(VALUE self) {
1536
+ struct rb_libarchive_archive_container *p;
1537
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1538
+ Check_Archive(p);
1539
+ rb_libarchive_writer_close0(p);
1540
+ return Qnil;
1541
+ }
1542
+
1543
+ static VALUE rb_libarchive_writer_s_open0(int (*archive_open)(struct rb_libarchive_archive_container *, void *), void *arg, int compression, int format, const char *cmd) {
1544
+ VALUE writer;
1545
+ struct rb_libarchive_archive_container *p;
1546
+ int r;
1547
+ writer = rb_funcall(rb_cArchiveWriter, rb_intern("new"), 0);
1548
+ Data_Get_Struct(writer, struct rb_libarchive_archive_container, p);
1549
+
1550
+ if ((p->ar = archive_write_new()) == NULL) {
1551
+ rb_raise(rb_eArchiveError, "Open writer failed: %s", strerror(errno));
1552
+ }
1553
+
1554
+ if (cmd != NULL) {
1555
+ r = archive_write_set_compression_program(p->ar, cmd);
1556
+ } else {
1557
+ r = archive_write_set_compression(p->ar, compression);
1558
+ }
1559
+
1560
+ if (r != ARCHIVE_OK) {
1561
+ char error_string[BUFSIZ];
1562
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1563
+ rb_libarchive_writer_close0(p);
1564
+ rb_raise(rb_eArchiveError, "Set compression failed: %s", error_string);
1565
+ }
1566
+
1567
+ if (archive_write_set_format(p->ar, format) != ARCHIVE_OK) {
1568
+ char error_string[BUFSIZ];
1569
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1570
+ rb_libarchive_writer_close0(p);
1571
+ rb_raise(rb_eArchiveError, "Set format failed: %s", error_string);
1572
+ }
1573
+
1574
+ if (archive_open(p, arg) != ARCHIVE_OK) {
1575
+ char error_string[BUFSIZ];
1576
+ archive_copy_error_string(p->ar, error_string, BUFSIZ);
1577
+ rb_libarchive_writer_close0(p);
1578
+ rb_raise(rb_eArchiveError, "Open writer failed: %s", error_string);
1579
+ }
1580
+
1581
+ if (rb_block_given_p()) {
1582
+ VALUE retval;
1583
+ int status;
1584
+ retval = rb_protect(rb_yield, writer, &status);
1585
+ rb_libarchive_writer_close0(p);
1586
+
1587
+ if (status != 0) {
1588
+ rb_jump_tag(status);
1589
+ }
1590
+
1591
+ return retval;
1592
+ } else {
1593
+ return writer;
1594
+ }
1595
+ }
1596
+
1597
+ static int rb_libarchive_writer_s_open_filename0(struct rb_libarchive_archive_container *p, void *arg) {
1598
+ const char *filename = (const char *) arg;
1599
+ return archive_write_open_filename(p->ar, filename);
1600
+ }
1601
+
1602
+ /* */
1603
+ static VALUE rb_libarchive_writer_s_open_filename(VALUE self, VALUE v_filename, VALUE v_compression, VALUE v_format) {
1604
+ const char *filename = NULL;
1605
+ int compression, format;
1606
+ const char *cmd = NULL;
1607
+ Check_Type(v_filename, T_STRING);
1608
+
1609
+ if (RSTRING_LEN(v_filename) < 1) {
1610
+ rb_raise(rb_eArchiveError, "Open writer failed: No such file or directory");
1611
+ }
1612
+
1613
+ filename = RSTRING_PTR(v_filename);
1614
+
1615
+ if (T_STRING == TYPE(v_compression)) {
1616
+ compression = -1;
1617
+ cmd = RSTRING_PTR(v_compression);
1618
+ } else {
1619
+ compression = NUM2INT(v_compression);
1620
+ }
1621
+
1622
+
1623
+ format = NUM2INT(v_format);
1624
+ return rb_libarchive_writer_s_open0(rb_libarchive_writer_s_open_filename0, (void *) filename, compression, format, cmd);
1625
+ }
1626
+
1627
+ static int rb_libarchive_writer_s_open_memory0(struct rb_libarchive_archive_container *p, void *arg) {
1628
+ VALUE str = (VALUE) arg;
1629
+ p->memory = str;
1630
+ return archive_write_open_rb_str(p->ar, str);
1631
+ }
1632
+
1633
+ /* */
1634
+ static VALUE rb_libarchive_writer_s_open_memory(VALUE self, VALUE v_memory, VALUE v_compression, VALUE v_format) {
1635
+ int compression, format;
1636
+ const char *cmd = NULL;
1637
+ Check_Type(v_memory, T_STRING);
1638
+
1639
+ if (T_STRING == TYPE(v_compression)) {
1640
+ compression = -1;
1641
+ cmd = RSTRING_PTR(v_compression);
1642
+ } else {
1643
+ compression = NUM2INT(v_compression);
1644
+ }
1645
+
1646
+ format = NUM2INT(v_format);
1647
+ return rb_libarchive_writer_s_open0(rb_libarchive_writer_s_open_memory0, (void *) v_memory, compression, format, cmd);
1648
+ }
1649
+
1650
+ /* */
1651
+ static VALUE rb_libarchive_writer_new_entry(VALUE self) {
1652
+ VALUE entry;
1653
+ struct rb_libarchive_archive_container *p;
1654
+ struct archive_entry *ae;
1655
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1656
+ Check_Archive(p);
1657
+
1658
+ if ((ae = archive_entry_new()) == NULL) {
1659
+ rb_raise(rb_eArchiveError, "New entry failed: %s", strerror(errno));
1660
+ }
1661
+
1662
+ entry = rb_libarchive_entry_new(ae, 1);
1663
+
1664
+ if (rb_block_given_p()) {
1665
+ VALUE retval;
1666
+ int status;
1667
+ retval = rb_protect(rb_yield, entry, &status);
1668
+ rb_libarchive_entry_close(entry);
1669
+
1670
+ if (status != 0) {
1671
+ rb_jump_tag(status);
1672
+ }
1673
+
1674
+ return retval;
1675
+ } else {
1676
+ return entry;
1677
+ }
1678
+ }
1679
+
1680
+ /* */
1681
+ static VALUE rb_libarchive_writer_write_header(VALUE self, VALUE v_entry) {
1682
+ struct rb_libarchive_archive_container *pa;
1683
+ struct rb_libarchive_entry_container *pae;
1684
+ Check_Class(v_entry, rb_cArchiveEntry);
1685
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, pa);
1686
+ Check_Archive(pa);
1687
+ Data_Get_Struct(v_entry, struct rb_libarchive_entry_container, pae);
1688
+ Check_Entry(pae);
1689
+
1690
+ if (archive_write_header(pa->ar, pae->ae) != ARCHIVE_OK) {
1691
+ rb_raise(rb_eArchiveError, "Write header failed: %s", archive_error_string(pa->ar));
1692
+ }
1693
+
1694
+ return Qnil;
1695
+ }
1696
+
1697
+ static ssize_t rb_libarchive_writer_write_data0(struct archive *ar, VALUE v_buff) {
1698
+ const char *buff;
1699
+ size_t size;
1700
+ ssize_t n;
1701
+
1702
+ if (NIL_P(v_buff)) {
1703
+ return 0;
1704
+ }
1705
+
1706
+ Check_Type(v_buff, T_STRING);
1707
+ buff = RSTRING_PTR(v_buff);
1708
+ size = RSTRING_LEN(v_buff);
1709
+
1710
+ if (size < 1) {
1711
+ return 0;
1712
+ }
1713
+
1714
+ if ((n = archive_write_data(ar, buff, size)) < 0) {
1715
+ rb_raise(rb_eArchiveError, "Write data failed: %s", archive_error_string(ar));
1716
+ }
1717
+
1718
+ return n;
1719
+ }
1720
+
1721
+ /* */
1722
+ static VALUE rb_libarchive_writer_write_data(int argc, VALUE *argv, VALUE self) {
1723
+ struct rb_libarchive_archive_container *p;
1724
+ Data_Get_Struct(self, struct rb_libarchive_archive_container, p);
1725
+ Check_Archive(p);
1726
+
1727
+ if (rb_block_given_p()) {
1728
+ ssize_t len = 0;
1729
+
1730
+ if (argc > 0) {
1731
+ rb_raise(rb_eArgError, "wrong number of arguments (%d for 0)", argc);
1732
+ }
1733
+
1734
+ while(1) {
1735
+ VALUE retval;
1736
+ ssize_t n;
1737
+ retval = rb_yield(Qnil);
1738
+
1739
+ if ((n = rb_libarchive_writer_write_data0(p->ar, retval)) < 1) {
1740
+ return LONG2NUM(len);
1741
+ }
1742
+
1743
+ len += n;
1744
+ }
1745
+ } else {
1746
+ VALUE v_buff;
1747
+ ssize_t n;
1748
+ rb_scan_args(argc, argv, "10", &v_buff);
1749
+ n = rb_libarchive_writer_write_data0(p->ar, v_buff);
1750
+ return LONG2NUM(n);
1751
+ }
1752
+ }
1753
+
1754
+ void Init_libarchive_writer() {
1755
+ rb_cArchiveWriter = rb_define_class_under(rb_mArchive, "Writer", rb_cObject);
1756
+ rb_define_alloc_func(rb_cArchiveWriter, rb_libarchive_archive_alloc);
1757
+ rb_funcall(rb_cArchiveWriter, rb_intern("private_class_method"), 1, ID2SYM(rb_intern("new")));
1758
+ rb_define_singleton_method(rb_cArchiveWriter, "open_filename", rb_libarchive_writer_s_open_filename, 3);
1759
+ rb_define_singleton_method(rb_mArchive, "write_open_filename", rb_libarchive_writer_s_open_filename, 3);
1760
+ rb_define_singleton_method(rb_cArchiveWriter, "open_memory", rb_libarchive_writer_s_open_memory, 3);
1761
+ rb_define_singleton_method(rb_mArchive, "write_open_memory", rb_libarchive_writer_s_open_memory, 3);
1762
+ rb_define_method(rb_cArchiveWriter, "close", rb_libarchive_writer_close, 0);
1763
+ rb_define_method(rb_cArchiveWriter, "new_entry", rb_libarchive_writer_new_entry, 0);
1764
+ rb_define_method(rb_cArchiveWriter, "write_header", rb_libarchive_writer_write_header, 1);
1765
+ rb_define_method(rb_cArchiveWriter, "write_data", rb_libarchive_writer_write_data, -1);
1766
+ }