master_loader.cc 15.4 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
#include <dns/master_lexer.h>
#include <dns/name.h>
18
#include <dns/rdataclass.h>
19 20 21
#include <dns/rrttl.h>
#include <dns/rrclass.h>
#include <dns/rrtype.h>
Michal 'vorner' Vaner's avatar
Michal 'vorner' Vaner committed
22
#include <dns/rdata.h>
23

24 25
#include <boost/scoped_ptr.hpp>

26
#include <string>
27
#include <memory>
28
#include <boost/algorithm/string/predicate.hpp> // for iequals
29

30
using std::string;
31
using std::auto_ptr;
32
using boost::algorithm::iequals;
33 34 35 36

namespace isc {
namespace dns {

37 38 39 40 41 42 43 44 45 46
// 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)
    {}
};

47 48 49 50
class MasterLoader::MasterLoaderImpl {
public:
    MasterLoaderImpl(const char* master_file,
                     const Name& zone_origin,
51 52
                     const RRClass& zone_class,
                     const MasterLoaderCallbacks& callbacks,
53
                     const AddRRCallback& add_callback,
54 55 56 57 58
                     MasterLoader::Options options) :
        lexer_(),
        zone_origin_(zone_origin),
        zone_class_(zone_class),
        callbacks_(callbacks),
59
        add_callback_(add_callback),
60 61 62
        options_(options),
        master_file_(master_file),
        initialized_(false),
63
        ok_(true),
64
        many_errors_((options & MANY_ERRORS) != 0),
65
        source_count_(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 99
        ++source_count_;
    }

    bool popSource() {
100 101 102
        if (--source_count_ == 0) {
            return (false);
        }
103
        lexer_.popSource();
104
        return (true);
105 106 107 108 109
    }

    void pushStreamSource(std::istream& stream) {
        lexer_.pushSource(stream);
        initialized_ = true;
110
        ++source_count_;
111 112
    }

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

119
    bool loadIncremental(size_t count_limit);
120

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

        // 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);
141 142
    }

143
    void setDefaultTTL(const RRTTL& ttl) {
144
        if (!default_ttl_) {
145
            default_ttl_.reset(new RRTTL(ttl));
146
        } else {
147
            *default_ttl_ = ttl;
148
        }
149 150 151 152
    }

    void setDefaultTTL(const string& ttl_txt) {
        setDefaultTTL(RRTTL(ttl_txt));
153
        eatUntilEOL(true);
154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172
    }

    void setCurrentTTL(const RRTTL& ttl) {
        if (!current_ttl_) {
            current_ttl_.reset(new RRTTL(ttl));
        } else {
            *current_ttl_ = ttl;
        }
    }

    bool setCurrentTTL(const string& ttl_txt) {
        try {
            setCurrentTTL(RRTTL(ttl_txt));
            return (true);
        } catch (const InvalidRRTTL&) {
            return (false);
        }
    }

173
    void handleDirective(const char* directive, size_t length) {
174
        if (iequals(directive, "INCLUDE")) {
175
            doInclude();
176
        } else if (iequals(directive, "ORIGIN")) {
177 178 179
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "Origin directive not implemented yet");
180
        } else if (iequals(directive, "TTL")) {
181
            setDefaultTTL(getString());
182 183 184 185 186 187
        } else {
            isc_throw(InternalException, "Unknown directive '" <<
                      string(directive, directive + length) << "'");
        }
    }

188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216
    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;
            }
        }
    }

217 218
private:
    MasterLexer lexer_;
219
    const Name zone_origin_;
220 221
    const RRClass zone_class_;
    MasterLoaderCallbacks callbacks_;
222
    AddRRCallback add_callback_;
223 224
    boost::scoped_ptr<RRTTL> default_ttl_;
    boost::scoped_ptr<RRTTL> current_ttl_;
JINMEI Tatuya's avatar
JINMEI Tatuya committed
225
    const MasterLoader::Options options_;
226
    const std::string master_file_;
227
    std::string string_token_;
228
    bool initialized_;
229 230 231
    bool ok_;                   // Is it OK to continue loading?
    const bool many_errors_;    // Are many errors allowed (or should we abort
                                // on the first)
232
    size_t source_count_;       // How many sources are currently pushed.
233
public:
234 235 236
    bool complete_;             // All work done.
    bool seen_error_;           // Was there at least one error during the
                                // load?
237 238
};

239 240
bool
MasterLoader::MasterLoaderImpl::loadIncremental(size_t count_limit) {
241 242 243
    if (count_limit == 0) {
        isc_throw(isc::InvalidParameter, "Count limit set to 0");
    }
244 245 246 247 248 249 250 251 252 253 254 255 256 257 258
    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) {
259 260 261 262
                    if (!popSource()) {
                        return (true);
                    } else {
                        // We try to read a token from the popped source
263 264 265
                        // So retry the loop, but first, make sure the source
                        // is at EOL
                        eatUntilEOL(true);
266 267
                        continue;
                    }
268 269 270 271 272 273
                }
                empty = empty_token.getType() == MasterToken::END_OF_LINE;
            } while (empty);
            // Return the last token, as it was not empty
            lexer_.ungetToken();

274
            const MasterToken::StringRegion&
275 276
                name_string(lexer_.getNextToken(MasterToken::QSTRING).
                            getStringRegion());
277 278 279 280 281 282 283 284 285 286 287 288 289

            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;
            }

290 291 292 293 294 295
            const Name name(name_string.beg, name_string.len,
                            &zone_origin_);
            // TODO: Some more flexibility. We don't allow omitting
            // anything yet

            // The parameters
296
            MasterToken rrparam_token = lexer_.getNextToken();
297 298

            bool explicit_ttl = false;
299 300 301
            if (rrparam_token.getType() == MasterToken::STRING) {
                // Try TTL
                if (setCurrentTTL(rrparam_token.getString())) {
302
                    explicit_ttl = true;
303 304 305 306 307
                    rrparam_token = lexer_.getNextToken();
                }
            }

            const RRClass rrclass(rrparam_token.getString());
308 309 310 311 312 313 314 315 316
            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_);
            }
Michal 'vorner' Vaner's avatar
Michal 'vorner' Vaner committed
317
            // TODO: Check if it is SOA, it should be at the origin.
318 319 320 321 322 323 324 325 326 327

            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.
328
            if (data) {
329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
                // If the TTL is not yet determined, complete it.
                if (!current_ttl_ && !default_ttl_) {
                    if (rrtype == RRType::SOA()) {
                        callbacks_.warning(lexer_.getSourceName(),
                                           lexer_.getSourceLine(),
                                           "no TTL specified; "
                                           "using SOA MINTTL instead");
                        const uint32_t ttl_val =
                            dynamic_cast<const rdata::generic::SOA&>(*data).
                            getMinimum();
                        setDefaultTTL(RRTTL(ttl_val));
                        setCurrentTTL(*default_ttl_);
                    }
                } else if (!explicit_ttl && default_ttl_) {
                    setCurrentTTL(*default_ttl_);
                } else if (!explicit_ttl) {
                    ;           // warn it
                }               // else, explicit_ttl, that's used

348
                add_callback_(name, rrclass, rrtype, *current_ttl_, data);
349 350 351

                // Good, we loaded another one
                ++count;
352 353 354 355 356 357 358 359 360
            } 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");
                }
361 362 363 364 365 366 367 368 369 370 371 372
            }
        } 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());
373
            eatUntilEOL(false);
374 375 376 377 378 379
        }
    }
    // When there was a fatal error and ok is false, we say we are done.
    return (!ok_);
}

380 381
MasterLoader::MasterLoader(const char* master_file,
                           const Name& zone_origin,
382 383
                           const RRClass& zone_class,
                           const MasterLoaderCallbacks& callbacks,
384
                           const AddRRCallback& add_callback,
385 386
                           Options options)
{
387 388 389
    if (add_callback.empty()) {
        isc_throw(isc::InvalidParameter, "Empty add RR callback");
    }
390
    impl_ = new MasterLoaderImpl(master_file, zone_origin,
391
                                 zone_class, callbacks, add_callback, options);
392 393
}

394 395 396 397 398 399 400 401 402 403
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");
    }
404 405 406 407 408 409
    auto_ptr<MasterLoaderImpl> impl(new MasterLoaderImpl("", zone_origin,
                                                         zone_class, callbacks,
                                                         add_callback,
                                                         options));
    impl->pushStreamSource(stream);
    impl_ = impl.release();
410 411
}

412 413 414 415 416 417
MasterLoader::~MasterLoader() {
    delete impl_;
}

bool
MasterLoader::loadIncremental(size_t count_limit) {
JINMEI Tatuya's avatar
JINMEI Tatuya committed
418
    const bool result = impl_->loadIncremental(count_limit);
419 420
    impl_->complete_ = result;
    return (result);
421 422
}

423 424 425 426 427
bool
MasterLoader::loadedSucessfully() const {
    return (impl_->complete_ && !impl_->seen_error_);
}

428 429
} // end namespace dns
} // end namespace isc