master_loader.cc 13.1 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
// Copyright (C) 2012  Internet Systems Consortium, Inc. ("ISC")
//
// Permission to use, copy, modify, and/or distribute this software for any
// purpose with or without fee is hereby granted, provided that the above
// copyright notice and this permission notice appear in all copies.
//
// THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
// REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
// AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
// INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
// LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
// OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
// PERFORMANCE OF THIS SOFTWARE.

#include <dns/master_loader.h>
16 17 18 19 20
#include <dns/master_lexer.h>
#include <dns/name.h>
#include <dns/rrttl.h>
#include <dns/rrclass.h>
#include <dns/rrtype.h>
Michal 'vorner' Vaner's avatar
Michal 'vorner' Vaner committed
21
#include <dns/rdata.h>
22

23
#include <string>
24
#include <memory>
25
#include <boost/algorithm/string/predicate.hpp> // for iequals
26

27
using std::string;
28
using std::auto_ptr;
29
using boost::algorithm::iequals;
30 31 32 33

namespace isc {
namespace dns {

34 35
namespace {

36 37 38 39 40 41 42 43 44 45
// An internal exception, used to control the code flow in case of errors.
// It is thrown during the loading and caught later, not to be propagated
// outside of the file.
class InternalException : public isc::Exception {
public:
    InternalException(const char* filename, size_t line, const char* what) :
        Exception(filename, line, what)
    {}
};

46 47
}

48 49 50 51
class MasterLoader::MasterLoaderImpl {
public:
    MasterLoaderImpl(const char* master_file,
                     const Name& zone_origin,
52 53
                     const RRClass& zone_class,
                     const MasterLoaderCallbacks& callbacks,
54
                     const AddRRCallback& add_callback,
55 56 57 58 59
                     MasterLoader::Options options) :
        lexer_(),
        zone_origin_(zone_origin),
        zone_class_(zone_class),
        callbacks_(callbacks),
60
        add_callback_(add_callback),
61 62 63
        options_(options),
        master_file_(master_file),
        initialized_(false),
64
        ok_(true),
65
        many_errors_((options & MANY_ERRORS) != 0),
66 67
        complete_(false),
        seen_error_(false)
68 69
    {}

70 71 72
    void reportError(const std::string& filename, size_t line,
                     const std::string& reason)
    {
73
        seen_error_ = true;
74
        callbacks_.error(filename, line, reason);
75
        if (!many_errors_) {
76 77 78 79 80 81 82 83
            // In case we don't have the lenient mode, every error is fatal
            // and we throw
            ok_ = false;
            complete_ = true;
            isc_throw(MasterLoaderError, reason.c_str());
        }
    }

84 85 86
    void pushSource(const std::string& filename) {
        std::string error;
        if (!lexer_.pushSource(filename.c_str(), &error)) {
87
            if (initialized_) {
88
                isc_throw(InternalException, error.c_str());
89 90 91 92 93
            } else {
                // Top-level file
                reportError("", 0, error);
                ok_ = false;
            }
94
        }
95
        initialized_ = true;
96 97 98
    }

    bool popSource() {
99
        if (lexer_.getSourceCount() == 1) {
100 101
            return (false);
        }
102
        lexer_.popSource();
103
        return (true);
104 105 106 107 108
    }

    void pushStreamSource(std::istream& stream) {
        lexer_.pushSource(stream);
        initialized_ = true;
109 110
    }

111 112
    // Get a string token. Handle it as error if it is not string.
    const string getString() {
113
        lexer_.getNextToken(MasterToken::STRING).getString(string_token_);
114
        return (string_token_);
115 116
    }

117
    bool loadIncremental(size_t count_limit);
118

119 120
    void doInclude() {
        // First, get the filename to include
121 122
        const string
            filename(lexer_.getNextToken(MasterToken::QSTRING).getString());
123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138

        // There could be an origin (or maybe not). So try looking
        const MasterToken name_tok(lexer_.getNextToken(MasterToken::QSTRING,
                                                       true));

        if (name_tok.getType() == MasterToken::QSTRING ||
            name_tok.getType() == MasterToken::STRING) {
            // TODO: Handle the origin. Once we complete #2427.
        } else {
            // We return the newline there. This is because after we pop
            // the source, we want to call eatUntilEOL and this would
            // eat to the next one.
            lexer_.ungetToken();
        }

        pushSource(filename);
139 140
    }

141
    void handleDirective(const char* directive, size_t length) {
142
        if (iequals(directive, "INCLUDE")) {
143
            doInclude();
144
        } else if (iequals(directive, "ORIGIN")) {
145 146 147
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "Origin directive not implemented yet");
148
        } else if (iequals(directive, "TTL")) {
149 150 151 152 153 154 155 156 157
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "TTL directive not implemented yet");
        } else {
            isc_throw(InternalException, "Unknown directive '" <<
                      string(directive, directive + length) << "'");
        }
    }

158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
    void eatUntilEOL(bool reportExtra) {
        // We want to continue. Try to read until the end of line
        for (;;) {
            const MasterToken& token(lexer_.getNextToken());
            switch (token.getType()) {
                case MasterToken::END_OF_FILE:
                    callbacks_.warning(lexer_.getSourceName(),
                                       lexer_.getSourceLine(),
                                       "Unexpected end ond of file");
                    // We don't pop here. The End of file will stay there,
                    // and we'll handle it in the next iteration of
                    // loadIncremental properly.
                    return;
                case MasterToken::END_OF_LINE:
                    // Found the end of the line. Good.
                    return;
                default:
                    // Some other type of token.
                    if (reportExtra) {
                        reportExtra = false;
                        reportError(lexer_.getSourceName(),
                                    lexer_.getSourceLine(),
                                    "Extra tokens at the end of line");
                    }
                    break;
            }
        }
    }

187 188
private:
    MasterLexer lexer_;
189
    const Name zone_origin_;
190 191
    const RRClass zone_class_;
    MasterLoaderCallbacks callbacks_;
192
    AddRRCallback add_callback_;
JINMEI Tatuya's avatar
JINMEI Tatuya committed
193
    const MasterLoader::Options options_;
194
    const std::string master_file_;
195
    std::string string_token_;
196
    bool initialized_;
197 198 199
    bool ok_;                   // Is it OK to continue loading?
    const bool many_errors_;    // Are many errors allowed (or should we abort
                                // on the first)
200
public:
201 202 203
    bool complete_;             // All work done.
    bool seen_error_;           // Was there at least one error during the
                                // load?
204 205
};

206 207
bool
MasterLoader::MasterLoaderImpl::loadIncremental(size_t count_limit) {
208 209 210
    if (count_limit == 0) {
        isc_throw(isc::InvalidParameter, "Count limit set to 0");
    }
211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
    if (complete_) {
        isc_throw(isc::InvalidOperation,
                  "Trying to load when already loaded");
    }
    if (!initialized_) {
        pushSource(master_file_);
    }
    size_t count = 0;
    while (ok_ && count < count_limit) {
        try {
            // Skip all EOLNs (empty lines) and finish on EOF
            bool empty = true;
            do {
                const MasterToken& empty_token(lexer_.getNextToken());
                if (empty_token.getType() == MasterToken::END_OF_FILE) {
226 227 228 229
                    if (!popSource()) {
                        return (true);
                    } else {
                        // We try to read a token from the popped source
230 231 232
                        // So retry the loop, but first, make sure the source
                        // is at EOL
                        eatUntilEOL(true);
233 234
                        continue;
                    }
235 236 237 238 239 240
                }
                empty = empty_token.getType() == MasterToken::END_OF_LINE;
            } while (empty);
            // Return the last token, as it was not empty
            lexer_.ungetToken();

241
            const MasterToken::StringRegion&
242 243
                name_string(lexer_.getNextToken(MasterToken::QSTRING).
                            getStringRegion());
244 245 246 247 248 249 250 251 252 253 254 255 256

            if (name_string.len > 0 && name_string.beg[0] == '$') {
                // This should have either thrown (and the error handler
                // will read up until the end of line) or read until the
                // end of line.

                // Exclude the $ from the string on this point.
                handleDirective(name_string.beg + 1, name_string.len - 1);
                // So, get to the next line, there's nothing more interesting
                // in this one.
                continue;
            }

257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
            const Name name(name_string.beg, name_string.len,
                            &zone_origin_);
            // TODO: Some more flexibility. We don't allow omitting
            // anything yet

            // The parameters
            const RRTTL ttl(getString());
            const RRClass rrclass(getString());
            const RRType rrtype(getString());

            // TODO: Some more validation?
            if (rrclass != zone_class_) {
                // It doesn't really matter much what type of exception
                // we throw, we catch it just below.
                isc_throw(isc::BadValue, "Class mismatch: " << rrclass <<
                          "vs. " << zone_class_);
            }

            const rdata::RdataPtr data(rdata::createRdata(rrtype, rrclass,
                                                          lexer_,
                                                          &zone_origin_,
                                                          options_,
                                                          callbacks_));
            // In case we get NULL, it means there was error creating
            // the Rdata. The errors should have been reported by
            // callbacks_ already. We need to decide if we want to continue
            // or not.
284
            if (data) {
285 286 287 288
                add_callback_(name, rrclass, rrtype, ttl, data);

                // Good, we loaded another one
                ++count;
289 290 291 292 293 294 295 296 297
            } else {
                seen_error_ = true;
                if (!many_errors_) {
                    ok_ = false;
                    complete_ = true;
                    // We don't have the exact error here, but it was reported
                    // by the error callback.
                    isc_throw(MasterLoaderError, "Invalid RR data");
                }
298 299 300 301 302 303 304 305 306 307 308 309
            }
        } catch (const MasterLoaderError&) {
            // This is a hack. We exclude the MasterLoaderError from the
            // below case. Once we restrict the below to some smaller
            // exception, we should remove this.
            throw;
        } catch (const isc::Exception& e) {
            // TODO: Once we do #2518, catch only the DNSTextError here,
            // not isc::Exception. The rest should be just simply
            // propagated.
            reportError(lexer_.getSourceName(), lexer_.getSourceLine(),
                        e.what());
310
            eatUntilEOL(false);
311 312 313 314 315 316
        }
    }
    // When there was a fatal error and ok is false, we say we are done.
    return (!ok_);
}

317 318
MasterLoader::MasterLoader(const char* master_file,
                           const Name& zone_origin,
319 320
                           const RRClass& zone_class,
                           const MasterLoaderCallbacks& callbacks,
321
                           const AddRRCallback& add_callback,
322 323
                           Options options)
{
324 325 326
    if (add_callback.empty()) {
        isc_throw(isc::InvalidParameter, "Empty add RR callback");
    }
327
    impl_ = new MasterLoaderImpl(master_file, zone_origin,
328
                                 zone_class, callbacks, add_callback, options);
329 330
}

331 332 333 334 335 336 337 338 339 340
MasterLoader::MasterLoader(std::istream& stream,
                           const Name& zone_origin,
                           const RRClass& zone_class,
                           const MasterLoaderCallbacks& callbacks,
                           const AddRRCallback& add_callback,
                           Options options)
{
    if (add_callback.empty()) {
        isc_throw(isc::InvalidParameter, "Empty add RR callback");
    }
341 342 343 344 345 346
    auto_ptr<MasterLoaderImpl> impl(new MasterLoaderImpl("", zone_origin,
                                                         zone_class, callbacks,
                                                         add_callback,
                                                         options));
    impl->pushStreamSource(stream);
    impl_ = impl.release();
347 348
}

349 350 351 352 353 354
MasterLoader::~MasterLoader() {
    delete impl_;
}

bool
MasterLoader::loadIncremental(size_t count_limit) {
JINMEI Tatuya's avatar
JINMEI Tatuya committed
355
    const bool result = impl_->loadIncremental(count_limit);
356 357
    impl_->complete_ = result;
    return (result);
358 359
}

360 361 362 363 364
bool
MasterLoader::loadedSucessfully() const {
    return (impl_->complete_ && !impl_->seen_error_);
}

365 366
} // end namespace dns
} // end namespace isc