Tcl 8.5 Network Programming电子书

Tcl 8.5 Network Programming

Table of Contents

Tcl 8.5 Network Programming

Credits

About the Authors

About the Reviewers

Preface

What this book covers

What you need for this book

Who this book is for

Conventions

Reader feedback

Customer support

Errata

Piracy

Questions

1. Introducing Tcl

What is Tcl/Tk

Extensions

Tk

Installation

Windows

Unix-like systems

Installation of additional Tcl packages

Additional tools

Eclipse

Komodo

tkcon — an alternate Tcl shell

Tcl syntax

Tcl commands documentation syntax

Running the script

Running commands directly in the tclsh interpreter

Variables

Grouping

Nesting commands

Data types

Lists

Arrays

array size

Dictionaries

Mathematical expressions—expr

Flow control and loop instructions

Flow control

Loops

Defining your own commands

Summary

2. Advanced Tcl Features

Tcl features

Working with time and date

Tcl data types

Global, namespace, and local variables

Stack frames

Object-oriented programming

Class definition

Inheritance

Object definitions

Using mixins

Forwarding methods

Additional information

Accessing files

Reading and writing files

Configuring channel options

File management

Filename related operations

File information

Listing files

Current working directory

Packages in Tcl

Package loading

Creating a package

Tcl modules

Event-driven programming

Tcl event types

Entering the event loop

Events and stack frames

Channel events

Timer and idle events

Robust scheduling with tclcron

Multithreaded applications

Managing threads

Shared variables

Transferring channels

Summary

3. Tcl Standalone Binaries

Understanding the executable file structure

Learning the Metakit database

Working with MetaKit from Tcl

Learning more about virtual file systems

Getting into the details of VFS and Metakit

Learning Tclkit

Starkit and SDX

Creating a Starkit file

Internal structure of starkits

Using resource files in starkits

Putting additional packages into a starkit

Format of the starkit file

Interactions between different starkit files

Knowing the Starpack technology

Practical example—the Hibernator application

Advanced topics—self updating

Other solutions

Summary

4. Troubleshooting Tcl applications

Logging

Log package

Initialization

Available log levels

Enabling or disabling log levels

Replacing the default implementation of the logging command

Recap of the log package

Logger package

Initialization

Available log levels

Enabling or disabling log levels

Tracing

Changing the implementation of the logging / tracing command

Appenders

Recap of the logger package

Audit

Recap of the audit package

Debugging

Tcl Dev Kit Inspector

Tcl Dev Kit Debugger

Local Debugging

Remote debugging

Recap of the Tcl Dev Kit Debugger

TclPro Debugger

Summary

5. Data Storage

Internationalizations

Encoding issues

Translating your application into different languages

Using SQL and databases in Tcl

Connecting to MySQL

Connecting to PostgreSQL

Using SQLite

Managing databases from SQLiteStudio

Other databases

Handling XML in Tcl

Storing raw Tcl values

Summary

6. Networking in Tcl

Using TCP sockets

Creating server sockets

Connecting over TCP

Using nonblocking sockets

Handling channel events

Transferring binary data

Transferring data using the fcopy command

Handling errors

Buffering

Using threads for networking

Using threads and thread pools

Connecting to our service

Using UDP sockets

Creating a UDP-based client

Implementing service using UDP

Sending reliable messages

Comparing TCP and UDP: streams vs. datagrams

Summary

7. Using Common Internet Services

Handling e-mail

Learning MIME

Content type

Multipart messages

MIME in Tcl

Creating messages

Multipart elements

Sending e-mails

Automated e-mail sending

Creating template based e-mails

Receiving e-mails

Using POP3 protocol in Tcl

Listing all messages

Retrieving e-mails using POP3

Parsing incoming e-mails

Transferring files and data

Resources and uri package

Using HTTP

Retrieving data over HTTP

Submitting information using GET and POST

Advanced topics

Cookies in Tcl

HTTP and encryption

Retrieving RSS information

Using FTP

Establishing connections

Retrieving files

Uploading files

Listing files and directories

Summary

8. Using Additional Internet Services

Checking DNS

Using callbacks

Getting the current date and time

Using LDAP from Tcl

Authenticating users over LDAP

Modifying information in LDAP

Communicating with Tcl applications

Comm client and server

Performing commands asynchronously

Security aspects

Limiting available commands

Summary

9. Learning SNMP

Introduction to SNMP

Learning SNMP protocol versions

Data objects

Working with SNMP and MIB

Setting up SNMP agent

Tcl and Scotty package

Obtaining Scotty

The TkIned application

Using Tcl for SNMP communication

Querying SNMP in Tcl

Performing asynchronous queries

Walking over MIB trees

Receiving traps

Sending traps

SNMP agent

Additional features

Summary

10. Web Programming in Tcl

Tcl scripts as CGI application

Using ncgi package

Using html package

Introduction to TclHttpd

Installation

Retrieving source code from the CVS repository

Documentation

First run

Startup parameters

Default directory structure

Configuration

Performance

Programming TclHttpd server

Providing static content

Using CGI in TclHttpd

Mapping URL to application

Creating document type handlers

Using the watermark example

Creating custom templates

Learning domain handlers

Setting up request handlers

Comparing domain handlers to application direct URLs

Creating session-based authentication

Using the TclHttpd template system

Securing access to resources

Debugging TclHttpd server

Embedding TclHttpd in your application

Summary

11. TclHttpd in Client-Server Applications

Creating HTTP-based applications

Preparing source code structure

Creating our applications

Server-side

Client-side

Communication and registration

Server-side

Client-side

Storing information

Server side

Client side

Comm interface—spooling jobs

Testing our applications

Adding autoupdate to application

Server-side

Client-side

Extending your applications

Starkits as extensions

Building modules

Server side

Handling modules on client

Communication with server

Improving scalability and performance

Summary

12. SOAP and XML-RPC

Tcl and standards for remote procedure calls

Connecting to XML-RPC services

Defining available methods

Specifying data types

Using XML-RPC

Using SOAP protocol

Creating Web Services

Setting up server

Creating a service

Specifying data types

Creating service methods

Defining data types

Using simple data types

Creating complex data types

Using data types inside service

Connecting to SOAP based services

Invoking methods via commands

Invoking methods API using DoCall commands

Using complex data types

Summary

13. SSL and Security

Learning Secure Socket Layer

Using SSL from Tcl

Generating self-signed certificates

Setting up and using public key infrastructure

Setting up certificates manually

Creating certificate authority

Generating and signing keys

Automating certificates from Tcl

Managing certificates from Tcl

Server side

Client side

Testing our solution

SSL and performance issues

Authorization and roles

Securing your application

Slave interpreters

Using slave interpreters

Sharing information with the slave interpreter

Creating and managing aliases

Deleting interpreters

Imposing limits on interpreters

Working with safe interpreters

Hiding and exposing commands

Default safe interpreter setup

Using Safe Base

Safe Base and filesystem access

Role-based authorization and interpreters

Creating interpreters using roles

Sample role definitions

Using role-based interpreters

Summary

Index