master_loader.cc 13.6 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 <strings.h>
26

27
using std::string;
28
using std::auto_ptr;
29 30 31 32

namespace isc {
namespace dns {

33 34 35 36 37 38 39 40 41 42
// 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)
    {}
};

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

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

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

    bool popSource() {
96 97 98
        if (--source_count_ == 0) {
            return (false);
        }
99
        lexer_.popSource();
100
        return (true);
101 102 103 104 105
    }

    void pushStreamSource(std::istream& stream) {
        lexer_.pushSource(stream);
        initialized_ = true;
106
        ++source_count_;
107 108
    }

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

115
    bool loadIncremental(size_t count_limit);
116

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

        // 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);
137 138
    }

139 140 141 142 143 144
    void handleDirective(const char* directive, size_t length) {
        // We use strncasecmp, because there seems to be no reasonable
        // way to compare strings case-insensitive in C++

        // Warning: The order of compared strings does matter. The length
        // parameter applies to the first one only.
145 146 147
        if (strncasecmp(directive, "INCLUDE", length) == 0) {
            doInclude();
        } else if (strncasecmp(directive, "ORIGIN", length) == 0) {
148 149 150
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "Origin directive not implemented yet");
151
        } else if (strncasecmp(directive, "TTL", length) == 0) {
152 153 154 155 156 157 158 159 160
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "TTL directive not implemented yet");
        } else {
            isc_throw(InternalException, "Unknown directive '" <<
                      string(directive, directive + length) << "'");
        }
    }

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 187 188 189
    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;
            }
        }
    }

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

210 211
bool
MasterLoader::MasterLoaderImpl::loadIncremental(size_t count_limit) {
212 213 214
    if (count_limit == 0) {
        isc_throw(isc::InvalidParameter, "Count limit set to 0");
    }
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229
    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) {
230 231 232 233
                    if (!popSource()) {
                        return (true);
                    } else {
                        // We try to read a token from the popped source
234 235 236
                        // So retry the loop, but first, make sure the source
                        // is at EOL
                        eatUntilEOL(true);
237 238
                        continue;
                    }
239 240 241 242 243 244
                }
                empty = empty_token.getType() == MasterToken::END_OF_LINE;
            } while (empty);
            // Return the last token, as it was not empty
            lexer_.ungetToken();

245
            const MasterToken::StringRegion&
246 247
                name_string(lexer_.getNextToken(MasterToken::QSTRING).
                            getStringRegion());
248 249 250 251 252 253 254 255 256 257 258 259 260

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

261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277
            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_);
            }
Michal 'vorner' Vaner's avatar
Michal 'vorner' Vaner committed
278
            // TODO: Check if it is SOA, it should be at the origin.
279 280 281 282 283 284 285 286 287 288

            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.
289
            if (data) {
290 291 292 293
                add_callback_(name, rrclass, rrtype, ttl, data);

                // Good, we loaded another one
                ++count;
294 295 296 297 298 299 300 301 302
            } 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");
                }
303 304 305 306 307 308 309 310 311 312 313 314
            }
        } 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());
315
            eatUntilEOL(false);
316 317 318 319 320 321
        }
    }
    // When there was a fatal error and ok is false, we say we are done.
    return (!ok_);
}

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

336 337 338 339 340 341 342 343 344 345
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");
    }
346 347 348 349 350 351
    auto_ptr<MasterLoaderImpl> impl(new MasterLoaderImpl("", zone_origin,
                                                         zone_class, callbacks,
                                                         add_callback,
                                                         options));
    impl->pushStreamSource(stream);
    impl_ = impl.release();
352 353
}

354 355 356 357 358 359
MasterLoader::~MasterLoader() {
    delete impl_;
}

bool
MasterLoader::loadIncremental(size_t count_limit) {
JINMEI Tatuya's avatar
JINMEI Tatuya committed
360
    const bool result = impl_->loadIncremental(count_limit);
361 362
    impl_->complete_ = result;
    return (result);
363 364
}

365 366 367 368 369
bool
MasterLoader::loadedSucessfully() const {
    return (impl_->complete_ && !impl_->seen_error_);
}

370 371
} // end namespace dns
} // end namespace isc