1

2

3

4

5

6

7

8

9

10

11

12

13

15

16#include <sys/stat.h>

17#include <sys/types.h>

18

19#include <cerrno>

20#include <cstdint>

21

22#if defined(_MSC_VER)

23#include <io.h>

24#define access _access

25#define F_OK 0

26#else

27#include <unistd.h>

28#endif

29

30#include <bzlib.h>

31#include <zlib.h>

32

33#include <cstdio>

34#include <cstdlib>

35#include <cstring>

36#include <memory>

37#include <string>

38

39#include "absl/log/check.h"

40#include "absl/log/log.h"

41#include "absl/status/status.h"

42#include "absl/strings/str_cat.h"

43#include "absl/strings/string_view.h"

44#include "google/protobuf/io/tokenizer.h"

45#include "google/protobuf/message.h"

46#include "google/protobuf/text_format.h"

47

48namespace {

49enum class Format { NORMAL_FILE, GZIP_FILE, BZIP2_FILE };

50

51static Format GetFormatFromName(absl::string_view name) {

52 const int size = name.size();

53 if (size > 4 && name.substr(size - 3) == ".gz") {

54 return Format::GZIP_FILE;

55 } else if (size > 5 && name.substr(size - 4) == ".bz2") {

56 return Format::BZIP2_FILE;

57 } else {

58 return Format::NORMAL_FILE;

59 }

60}

61

62class CFile : public File {

63 public:

64 CFile(FILE* c_file, absl::string_view name) : File(name), f_(c_file) {}

65 ~CFile() override = default;

66

67

68 size_t Read(void* buf, size_t size) override {

69 return fread(buf, 1, size, f_);

70 }

71

72

73 size_t Write(const void* buf, size_t size) override {

74 return fwrite(buf, 1, size, f_);

75 }

76

77

78 absl::Status Close(int ) override {

79 absl::Status status;

80 if (f_ == nullptr) {

81 return status;

82 }

83 if (fclose(f_) == 0) {

84 f_ = nullptr;

85 } else {

86 status.Update(

87 absl::Status(absl::StatusCode::kInvalidArgument,

88 absl::StrCat("Could not close file '", name_, "'")));

89 }

90 delete this;

91 return status;

92 }

93

94

95 bool Flush() override { return fflush(f_) == 0; }

96

97

98 size_t Size() override {

99 struct stat f_stat;

100 stat(name_.c_str(), &f_stat);

101 return f_stat.st_size;

102 }

103

104 bool Open() const override { return f_ != nullptr; }

105

106 private:

107 FILE* f_;

108};

109

110class GzFile : public File {

111 public:

112 GzFile(gzFile gz_file, absl::string_view name) : File(name), f_(gz_file) {}

113 ~GzFile() override = default;

114

115

116 size_t Read(void* buf, size_t size) override { return gzread(f_, buf, size); }

117

118

119 size_t Write(const void* buf, size_t size) override {

120 return gzwrite(f_, buf, size);

121 }

122

123

124 absl::Status Close(int ) override {

125 absl::Status status;

126 if (f_ == nullptr) {

127 return status;

128 }

129 if (gzclose(f_) == 0) {

130 f_ = nullptr;

131 } else {

132 status.Update(

133 absl::Status(absl::StatusCode::kInvalidArgument,

134 absl::StrCat("Could not close file '", name_, "'")));

135 }

136 delete this;

137 return status;

138 }

139

140

141 bool Flush() override { return gzflush(f_, Z_FINISH) == Z_OK; }

142

143

144 size_t Size() override {

145 gzFile file;

146 std::string null_terminated_name = std::string(name_);

147#if defined(_MSC_VER)

148 file = gzopen(null_terminated_name.c_str(), "rb");

149#else

150 file = gzopen(null_terminated_name.c_str(), "r");

151#endif

152 if (!file) {

153 LOG(FATAL) << "Cannot get the size of '" << name_

154 << "': " << strerror(errno);

155 }

156

157 const int kLength = 5 * 1024;

158 unsigned char buffer[kLength];

159 size_t uncompressed_size = 0;

160 while (true) {

161 int err;

162 int bytes_read;

163 bytes_read = gzread(file, buffer, kLength - 1);

164 uncompressed_size += bytes_read;

165 if (bytes_read < kLength - 1) {

166 if (gzeof(file)) {

167 break;

168 } else {

169 const char* error_string;

170 error_string = gzerror(file, &err);

171 if (err) {

172 LOG(FATAL) << "Error " << error_string;

173 }

174 }

175 }

176 }

177 gzclose(file);

178 return uncompressed_size;

179 }

180

181 bool Open() const override { return f_ != nullptr; }

182

183 private:

184 gzFile f_;

185};

186

187class Bz2File : public File {

188 public:

189 Bz2File(BZFILE* bz_file, absl::string_view name) : File(name), f_(bz_file) {}

190 ~Bz2File() override = default;

191

192

193 size_t Read(void* buf, size_t size) override {

194 return BZ2_bzread(f_, buf, size);

195 }

196

197

198 size_t Write(const void* buf, size_t size) override {

199 return BZ2_bzwrite(f_, const_cast<void*>(buf), size);

200 }

201

202

203 absl::Status Close(int ) override {

204 absl::Status status;

205 if (f_ == nullptr) {

206 return absl::OkStatus();

207 }

208 BZ2_bzclose(f_);

209 f_ = nullptr;

210 delete this;

211 return absl::OkStatus();

212 }

213

214

215 bool Flush() override { return BZ2_bzflush(f_) == 0; }

216

217

218 size_t Size() override {

219 BZFILE* file;

220 std::string null_terminated_name = std::string(name_);

221#if defined(_MSC_VER)

222 file = BZ2_bzopen(null_terminated_name.c_str(), "rb");

223#else

224 file = BZ2_bzopen(null_terminated_name.c_str(), "r");

225#endif

226 if (!file) {

227 LOG(FATAL) << "Cannot get the size of '" << name_

228 << "': " << strerror(errno);

229 }

230

231 const int kLength = 5 * 1024;

232 unsigned char buffer[kLength];

233 size_t uncompressed_size = 0;

234 while (true) {

235 int bytes_read;

236 bytes_read = BZ2_bzread(file, buffer, kLength - 1);

237 uncompressed_size += bytes_read;

238 if (bytes_read < kLength - 1) break;

239 }

240 BZ2_bzclose(file);

241 return uncompressed_size;

242 }

243

244 bool Open() const override { return f_ != nullptr; }

245

246 private:

247 BZFILE* f_;

248};

249

250}

251

253

259

294

318

322

324

326