master_loader.cc 15.9 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
        complete_(false),
67 68
        seen_error_(false),
        warn_rfc1035_ttl_(true)
69 70
    {}

71 72 73
    void reportError(const std::string& filename, size_t line,
                     const std::string& reason)
    {
74
        seen_error_ = true;
75
        callbacks_.error(filename, line, reason);
76
        if (!many_errors_) {
77 78 79 80 81 82 83 84
            // 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());
        }
    }

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

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

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

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

120
    bool loadIncremental(size_t count_limit);
121

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

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

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

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

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

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

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

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

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

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

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

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

            // The parameters
299
            MasterToken rrparam_token = lexer_.getNextToken();
300 301

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

            const RRClass rrclass(rrparam_token.getString());
311 312 313 314 315 316 317 318 319
            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
320
            // TODO: Check if it is SOA, it should be at the origin.
321 322 323 324 325 326 327 328 329 330

            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.
331
            if (data) {
332 333 334 335 336 337 338 339 340 341 342 343 344 345 346
                // 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_);
347 348 349 350 351 352 353 354
                } else if (!explicit_ttl && warn_rfc1035_ttl_) {
                    // Omitted (class and) TTL values are default to the last
                    // explicitly stated values (RFC 1035, Sec. 5.1).
                    callbacks_.warning(lexer_.getSourceName(),
                                       lexer_.getSourceLine(),
                                       "using RFC1035 TTL semantics");
                    warn_rfc1035_ttl_ = false; // we only warn about it once
                }
355

356
                add_callback_(name, rrclass, rrtype, *current_ttl_, data);
357 358 359

                // Good, we loaded another one
                ++count;
360 361 362 363 364 365 366 367 368
            } 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");
                }
369 370 371 372 373 374 375 376 377 378 379 380
            }
        } 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());
381
            eatUntilEOL(false);
382 383 384 385 386 387
        }
    }
    // When there was a fatal error and ok is false, we say we are done.
    return (!ok_);
}

388 389
MasterLoader::MasterLoader(const char* master_file,
                           const Name& zone_origin,
390 391
                           const RRClass& zone_class,
                           const MasterLoaderCallbacks& callbacks,
392
                           const AddRRCallback& add_callback,
393 394
                           Options options)
{
395 396 397
    if (add_callback.empty()) {
        isc_throw(isc::InvalidParameter, "Empty add RR callback");
    }
398
    impl_ = new MasterLoaderImpl(master_file, zone_origin,
399
                                 zone_class, callbacks, add_callback, options);
400 401
}

402 403 404 405 406 407 408 409 410 411
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");
    }
412 413 414 415 416 417
    auto_ptr<MasterLoaderImpl> impl(new MasterLoaderImpl("", zone_origin,
                                                         zone_class, callbacks,
                                                         add_callback,
                                                         options));
    impl->pushStreamSource(stream);
    impl_ = impl.release();
418 419
}

420 421 422 423 424 425
MasterLoader::~MasterLoader() {
    delete impl_;
}

bool
MasterLoader::loadIncremental(size_t count_limit) {
JINMEI Tatuya's avatar
JINMEI Tatuya committed
426
    const bool result = impl_->loadIncremental(count_limit);
427 428
    impl_->complete_ = result;
    return (result);
429 430
}

431 432 433 434 435
bool
MasterLoader::loadedSucessfully() const {
    return (impl_->complete_ && !impl_->seen_error_);
}

436 437
} // end namespace dns
} // end namespace isc