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 <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 119
    void doInclude() {
        // First, get the filename to include
        const MasterToken::StringRegion
120
            filename(lexer_.getNextToken(MasterToken::QSTRING).
121 122
                     getStringRegion());

123
        // TODO: Handle Origin
124 125 126 127 128 129 130

        // Push the filename. We abuse the fact that filename
        // may not contain '\0' anywhere in it, so we can
        // freely use the filename.beg directly.
        pushSource(filename.beg);
    }

131 132 133 134 135 136
    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.
137 138 139
        if (strncasecmp(directive, "INCLUDE", length) == 0) {
            doInclude();
        } else if (strncasecmp(directive, "ORIGIN", length) == 0) {
140 141 142
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "Origin directive not implemented yet");
143
        } else if (strncasecmp(directive, "TTL", length) == 0) {
144 145 146 147 148 149 150 151 152
            // TODO: Implement
            isc_throw(isc::NotImplemented,
                      "TTL directive not implemented yet");
        } else {
            isc_throw(InternalException, "Unknown directive '" <<
                      string(directive, directive + length) << "'");
        }
    }

153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181
    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;
            }
        }
    }

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

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

237
            const MasterToken::StringRegion&
238 239
                name_string(lexer_.getNextToken(MasterToken::QSTRING).
                            getStringRegion());
240 241 242 243 244 245 246 247 248 249 250 251 252

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

253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279
            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.
280
            if (data) {
281 282 283 284
                add_callback_(name, rrclass, rrtype, ttl, data);

                // Good, we loaded another one
                ++count;
285 286 287 288 289 290 291 292 293
            } 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");
                }
294 295 296 297 298 299 300 301 302 303 304 305
            }
        } 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());
306
            eatUntilEOL(false);
307 308 309 310 311 312
        }
    }
    // When there was a fatal error and ok is false, we say we are done.
    return (!ok_);
}

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

327 328 329 330 331 332 333 334 335 336
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");
    }
337 338 339 340 341 342
    auto_ptr<MasterLoaderImpl> impl(new MasterLoaderImpl("", zone_origin,
                                                         zone_class, callbacks,
                                                         add_callback,
                                                         options));
    impl->pushStreamSource(stream);
    impl_ = impl.release();
343 344
}

345 346 347 348 349 350
MasterLoader::~MasterLoader() {
    delete impl_;
}

bool
MasterLoader::loadIncremental(size_t count_limit) {
JINMEI Tatuya's avatar
JINMEI Tatuya committed
351
    const bool result = impl_->loadIncremental(count_limit);
352 353
    impl_->complete_ = result;
    return (result);
354 355
}

356 357 358 359 360
bool
MasterLoader::loadedSucessfully() const {
    return (impl_->complete_ && !impl_->seen_error_);
}

361 362
} // end namespace dns
} // end namespace isc