/mandos/release

« back to all changes in this revision

Viewing changes to mandos

• browse files at revision 161
• compare with another revision
• download diff
• download tarball
• view history from revision 161

• reverse the comparison (161 to 89)
• stop comparing with revision 89

Show diffs side-by-side

added

removed

mandos

24

24

#     GNU General Public License for more details.

25

25

# 

26

26

# You should have received a copy of the GNU General Public License

27

 

# along with this program.  If not, see <http://www.gnu.org/licenses/>.

 

27

# along with this program.  If not, see

 

28

# <http://www.gnu.org/licenses/>.

28

29

# 

29

30

# Contact the authors at <mandos@fukt.bsnet.se>.

30

31

# 

123

124

    def rename(self):

124

125

        """Derived from the Avahi example code"""

125

126

        if self.rename_count >= self.max_renames:

126

 

            logger.critical(u"No suitable service name found after %i"

127

 

                            u" retries, exiting.", rename_count)

 

127

            logger.critical(u"No suitable Zeroconf service name found"

 

128

                            u" after %i retries, exiting.",

 

129

                            rename_count)

128

130

            raise AvahiServiceError("Too many renames")

129

131

        self.name = server.GetAlternativeServiceName(self.name)

130

 

        logger.info(u"Changing name to %r ...", str(self.name))

 

132

        logger.info(u"Changing Zeroconf service name to %r ...",

 

133

                    str(self.name))

131

134

        syslogger.setFormatter(logging.Formatter\

132

135

                               ('Mandos (%s): %%(levelname)s:'

133

136

                               ' %%(message)s' % self.name))

148

151

                     avahi.DBUS_INTERFACE_ENTRY_GROUP)

149

152

            group.connect_to_signal('StateChanged',

150

153

                                    entry_group_state_changed)

151

 

        logger.debug(u"Adding service '%s' of type '%s' ...",

 

154

        logger.debug(u"Adding Zeroconf service '%s' of type '%s' ...",

152

155

                     service.name, service.type)

153

156

        group.AddService(

154

157

                self.interface,         # interface

337

340

            try:

338

341

                logger.info(u"Starting checker %r for %s",

339

342

                            command, self.name)

 

343

                # We don't need to redirect stdout and stderr, since

 

344

                # in normal mode, that is already done by daemon(),

 

345

                # and in debug mode we don't want to.  (Stdin is

 

346

                # always replaced by /dev/null.)

340

347

                self.checker = subprocess.Popen(command,

341

348

                                                close_fds=True,

342

349

                                                shell=True, cwd="/")

343

350

                self.checker_callback_tag = gobject.child_watch_add\

344

351

                                            (self.checker.pid,

345

352

                                             self.checker_callback)

346

 

            except subprocess.OSError, error:

 

353

            except OSError, error:

347

354

                logger.error(u"Failed to start subprocess: %s",

348

355

                             error)

349

356

        # Re-run this periodically if run by gobject.timeout_add

406

413

    gnutls.library.functions.gnutls_openpgp_crt_import\

407

414

                    (crt, ctypes.byref(datum),

408

415

                     gnutls.library.constants.GNUTLS_OPENPGP_FMT_RAW)

 

416

    # Verify the self signature in the key

 

417

    crtverify = ctypes.c_uint();

 

418

    gnutls.library.functions.gnutls_openpgp_crt_verify_self\

 

419

        (crt, 0, ctypes.byref(crtverify))

 

420

    if crtverify.value != 0:

 

421

        gnutls.library.functions.gnutls_openpgp_crt_deinit(crt)

 

422

        raise gnutls.errors.CertificateSecurityError("Verify failed")

409

423

    # New buffer for the fingerprint

410

424

    buffer = ctypes.create_string_buffer(20)

411

425

    buffer_length = ctypes.c_size_t()

563

577

    datetime.timedelta(1)

564

578

    >>> string_to_delta(u'1w')

565

579

    datetime.timedelta(7)

 

580

    >>> string_to_delta('5m 30s')

 

581

    datetime.timedelta(0, 330)

566

582

    """

567

 

    try:

568

 

        suffix=unicode(interval[-1])

569

 

        value=int(interval[:-1])

570

 

        if suffix == u"d":

571

 

            delta = datetime.timedelta(value)

572

 

        elif suffix == u"s":

573

 

            delta = datetime.timedelta(0, value)

574

 

        elif suffix == u"m":

575

 

            delta = datetime.timedelta(0, 0, 0, 0, value)

576

 

        elif suffix == u"h":

577

 

            delta = datetime.timedelta(0, 0, 0, 0, 0, value)

578

 

        elif suffix == u"w":

579

 

            delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

580

 

        else:

 

583

    timevalue = datetime.timedelta(0)

 

584

    for s in interval.split():

 

585

        try:

 

586

            suffix=unicode(s[-1])

 

587

            value=int(s[:-1])

 

588

            if suffix == u"d":

 

589

                delta = datetime.timedelta(value)

 

590

            elif suffix == u"s":

 

591

                delta = datetime.timedelta(0, value)

 

592

            elif suffix == u"m":

 

593

                delta = datetime.timedelta(0, 0, 0, 0, value)

 

594

            elif suffix == u"h":

 

595

                delta = datetime.timedelta(0, 0, 0, 0, 0, value)

 

596

            elif suffix == u"w":

 

597

                delta = datetime.timedelta(0, 0, 0, 0, 0, 0, value)

 

598

            else:

 

599

                raise ValueError

 

600

        except (ValueError, IndexError):

581

601

            raise ValueError

582

 

    except (ValueError, IndexError):

583

 

        raise ValueError

584

 

    return delta

 

602

        timevalue += delta

 

603

    return timevalue

585

604

 

586

605

 

587

606

def server_state_changed(state):

588

607

    """Derived from the Avahi example code"""

589

608

    if state == avahi.SERVER_COLLISION:

590

 

        logger.error(u"Server name collision")

 

609

        logger.error(u"Zeroconf server name collision")

591

610

        service.remove()

592

611

    elif state == avahi.SERVER_RUNNING:

593

612

        service.add()

595

614

 

596

615

def entry_group_state_changed(state, error):

597

616

    """Derived from the Avahi example code"""

598

 

    logger.debug(u"state change: %i", state)

 

617

    logger.debug(u"Avahi state change: %i", state)

599

618

    

600

619

    if state == avahi.ENTRY_GROUP_ESTABLISHED:

601

 

        logger.debug(u"Service established.")

 

620

        logger.debug(u"Zeroconf service established.")

602

621

    elif state == avahi.ENTRY_GROUP_COLLISION:

603

 

        logger.warning(u"Service name collision.")

 

622

        logger.warning(u"Zeroconf service name collision.")

604

623

        service.rename()

605

624

    elif state == avahi.ENTRY_GROUP_FAILURE:

606

 

        logger.critical(u"Error in group state changed %s",

 

625

        logger.critical(u"Avahi: Error in group state changed %s",

607

626

                        unicode(error))

608

627

        raise AvahiGroupError("State changed: %s", str(error))

609

628

 

732

751

    # Parse config file with clients

733

752

    client_defaults = { "timeout": "1h",

734

753

                        "interval": "5m",

735

 

                        "checker": "fping -q -- %%(host)s",

 

754

                        "checker": "fping -q -- %(host)s",

 

755

                        "host": "",

736

756

                        }

737

757

    client_config = ConfigParser.SafeConfigParser(client_defaults)

738

758

    client_config.read(os.path.join(server_settings["configdir"],

742

762

    service = AvahiService(name = server_settings["servicename"],

743

763

                           type = "_mandos._tcp", );

744

764

    if server_settings["interface"]:

745

 

        service.interface = if_nametoindex(server_settings["interface"])

 

765

        service.interface = if_nametoindex\

 

766

                            (server_settings["interface"])

746

767

    

747

768

    global main_loop

748

769

    global bus

751

772

    DBusGMainLoop(set_as_default=True )

752

773

    main_loop = gobject.MainLoop()

753

774

    bus = dbus.SystemBus()

754

 

    server = dbus.Interface(

755

 

            bus.get_object( avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER ),

756

 

            avahi.DBUS_INTERFACE_SERVER )

 

775

    server = dbus.Interface(bus.get_object(avahi.DBUS_NAME,

 

776

                                           avahi.DBUS_PATH_SERVER),

 

777

                            avahi.DBUS_INTERFACE_SERVER)

757

778

    # End of Avahi example code

758

779

    

759

780

    clients = Set()

772

793

        logger.critical(u"No clients defined")

773

794

        sys.exit(1)

774

795

    

775

 

    if not debug:

 

796

    if debug:

 

797

        # Redirect stdin so all checkers get /dev/null

 

798

        null = os.open(os.path.devnull, os.O_NOCTTY | os.O_RDWR)

 

799

        os.dup2(null, sys.stdin.fileno())

 

800

        if null > 2:

 

801

            os.close(null)

 

802

    else:

 

803

        # No console logging

776

804

        logger.removeHandler(console)

 

805

        # Close all input and output, do double fork, etc.

777

806

        daemon()

778

807

    

779

808

    pidfilename = "/var/run/mandos/mandos.pid"

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0