Free msg software for linux

Net::YMSG is a Perl interface to the Yahoo! Messenger IM protocol.

SYNOPSIS

use Net::YMSG;

my $yahoo = Net::YMSG->new(
id => your_yahoo_id,
password => your_password,
);
$yahoo->login or die "Cant login Yahoo!Messenger";
$yahoo->send(recipient_yahoo_id, Hello World!);

Net::YMSG is a client class for connecting with the Yahoo! Messenger server, and transmitting and receiving a message.

Since implement of a protocol is the result of analyzing and investigating a packet, it has an inadequate place. However, it is working as expected usually.

METHODS

This section documents method of the Net::YMSG class.

Net::YMSG->new()

It should be called with following arguments (items with default value are optional):

id => yahoo id
password => password
pre_login_url => url which refers to setting information.
(default http://msg.edit.yahoo.com/config/)
hostname => server hostname
(default scs.yahoo.com)

Returns a blessed instantiation of Net::YMSG.

Note: If you plan to connect with Yahoo!India (yahoo.co.in), it sets up as follows.

my $yahoo_japan = Net::YMSG->new(
pre_login_url => http://edit.my.yahoo.co.in/config/,
hostname => cs.yahoo.co.in,
);

Since it connects with Yahoo!(yahoo.com), this procedure is unnecessary in almost all countries.

mod_stego is an apache 1.x module. It steganograph a file or a message inside the html pages.

If you want the message, you should use a a de-steganography software to take it out.

Installation:

mod_stego.c

$ tar xvfz mod_stego-*tar.gz
$ tar xvfz apache_1.3.*.tar.gz
$ cd apache_1.3.*
$ PREFIX=/home/apache
$ ./configure --add-module=../mod_stego/mod_stego.c --prefix=$PREFIX
$ make
# make install
$ vi $PREFIX/conf/httpd.conf

Add:

AddHandler stego-handler .html .htm
StegoMessage /tmp/msg
StegoKey "Be happy!" # This is the key of your stego message. If there isnt
# it, the message isnt crypted. The algorithm is RC5.

stego_extractor.c

$ cc stego_extractor.c -o stego_extractor
$ wget www.autistici.org/bakunin/stego_example.html
$ ./stego_extractor stego_example.html

My page have no password (press enter 2 times).

MQSeries is a Perl extension for MQSeries support.

SYNOPSIS

There are two interfaces provided by the MQSeries modules. The first is a straight forward mapping to all of the individual MQI calls, and the second is a value-added, OO interface, which provides a simpler interface to a subset of the full MQI functionality.

The straight MQI mapping is:

use MQSeries;

$Hconn = MQCONN($Name,$CompCode,$Reason);
MQDISC($Hconn,$CompCode,$Reason);

$Hobj = MQOPEN($Hconn,$ObjDesc,$Options,$CompCode,$Reason);
MQCLOSE($Hconn,$Hobj,$Options,$CompCode,$Reason);

MQBACK($Hconn,$CompCode,$Reason);
MQCMIT($Hconn,$CompCode,$Reason);

$Buffer = MQGET($Hconn,$Hobj,$MsgDesc,$GetMsgOpts,$BufferLength,$CompCode,$Reason);

MQPUT($Hconn,$Hobj,$MsgDesc,%PutMsgOpts,$Msg,$CompCode,$Reason);

MQPUT1($Hconn,$ObjDesc,$MsgDesc,$PutMsgOpts,$Msg,$CompCode,$Reason);

($Attr1,...) = MQINQ($Hconn,$Hobj,$CompCode,$Reason,$Selector1,...);
MQSET($Hconn,$Hobj,$CompCode,$Reason,$Selector1,$Attr1,...);

If the perl5 API is compiled with the version 5 headers and libraries, then the following MQI calls are also available:

MQBEGIN($Hconn,$BeginOpts,$CompCode,$Reason);
$Hconn = MQCONNX($Name,$ConnectOpts,$CompCode,$Reason);

There are also some additional utility routines provided which are not part of the MQI, but specific to the perl5 API:

($ReasonText,$ReasonMacro) = MQReasonToStrings($Reason);
($ReasonText) = MQReasonToText($Reason);
($ReasonMacro) = MQReasonToMacro($Reason);

The OO interface is provided in several optional modules. Three of these make up the core OO interface:

MQSeries::QueueManager
MQSeries::Queue
MQSeries::Message

There are several subclasses of MQSeries::Message which handle special message formats:

MQSeries::Message::Storable
MQSeries::Message::Event
MQSeries::Message::PCF
MQSeries::Message::DeadLetter

There is also a module which provides an interface to the command server PCF messages for MQSeries administration:

MQSeries::Command

There are two sets of classes that help you follow (tail -f style) and parse the two kinds of log-files written by MQSeries: the FDC files and the error-logs. These classes allow you to write a log monitoring daemon that feeds into syslog or your system management tools.

MQSeries::ErrorLog::Tail
MQSeries::ErrorLog::Parser
MQSeries::ErrorLog::Entry
MQSeries::FDC::Tail
MQSeries::FDC::Parser
MQSeries::FDC::Entry

There is a set of classes that parses configuration and authority files (/var/mqm/mqs.ini, /var/mqm/qmgrs/*/qm.ini, /var/mqm/qmgrs/*/auth/*/*).

MQSeries::Config::Authority
MQSeries::Config::Machine
MQSeries::Config::QMgr

Some internal helper functions are stored in the module:

MQSeries::Utils

See the documentation for each of these individual modules for more information.

Mail::Send is a simple electronic mail interface.

SYNOPSIS:

require Mail::Send;

$msg = new Mail::Send;

$msg = new Mail::Send Subject=>example subject, To=>timbo;

$msg->to(user@host);
$msg->to(user@host, user2@example.com);
$msg->subject(example subject);
$msg->cc(user@host);
$msg->bcc(someone@else);

$msg->set($header, @values);
$msg->add($header, @values);
$msg->delete($header);

# Launch mailer and set headers. The filehandle returned
# by open() is an instance of the Mail::Mailer class.
# Arguments to the open() method are passed to the Mail::Mailer
# constructor.

$fh = $msg->open; # some default mailer
# $fh = $msg->open(sendmail); # explicit

print $fh "Body of message";

$fh->close; # complete the message and send it

$fh->cancel; # not yet implemented

Pod::Usage, pod2usage() can print a usage message from embedded pod documentation.

SYNOPSIS

use Pod::Usage

my $message_text = "This text precedes the usage message.";
my $exit_status = 2; ## The exit status to use
my $verbose_level = 0; ## The verbose level to use
my $filehandle = *STDERR; ## The filehandle to write to

pod2usage($message_text);

pod2usage($exit_status);

pod2usage( { -message => $message_text ,
-exitval => $exit_status ,
-verbose => $verbose_level,
-output => $filehandle } );

pod2usage( -msg => $message_text ,
-exitval => $exit_status ,
-verbose => $verbose_level,
-output => $filehandle );

pod2usage( -verbose => 2,
-noperldoc => 1 )

chan_misdn is a channel driver for the open source PBX Asterisk for using ISDN BRI/PRI devices that are supported by mISDN. chan_misdn is the new ISDN Layer for Linux.
Main features:
- NT and TE mode
- PP and PMP mode
- BRI and PRI (with BNE1 and BN2E1 Cards)
- DTMF Detection in HW+mISDNdsp (much better than asterisks internal!)
- Display Messages to Phones (which support display msg)
- HOLD/RETRIEVE/TRANSFER on ISDN Phones : )
- Screen/ Not Screen User Number
- Basic EchoCancellation
- Volume Control
- Crypting with mISDNdsp (Blowfish)
- Data (HDLC) callthrough
- Data Callin (with app_ptyfork +pppd)
- echo cancellation
- some other
Enhancements:
- Release management was changed.
- This is the first stable version.

MIME::Parser is a experimental class for parsing MIME streams.

SYNOPSIS

Before reading further, you should see MIME::Tools to make sure that you understand where this module fits into the grand scheme of things. Go on, do it now. Ill wait.
Ready? Ok...

Basic usage examples

### Create a new parser object:
my $parser = new MIME::Parser;

### Tell it where to put things:
$parser->output_under("/tmp");

### Parse an input filehandle:
$entity = $parser->parse(*STDIN);

### Congratulations: you now have a (possibly multipart) MIME entity!
$entity->dump_skeleton; # for debugging

Examples of input

### Parse from filehandles:
$entity = $parser->parse(*STDIN);
$entity = $parser->parse(IO::File->new("some command|");

### Parse from any object that supports getline() and read():
$entity = $parser->parse($myHandle);

### Parse an in-core MIME message:
$entity = $parser->parse_data($message);

### Parse an MIME message in a file:
$entity = $parser->parse_open("/some/file.msg");

### Parse an MIME message out of a pipeline:
$entity = $parser->parse_open("gunzip - < file.msg.gz |");

### Parse already-split input (as "deliver" would give it to you):
$entity = $parser->parse_two("msg.head", "msg.body");

Examples of output control

### Keep parsed message bodies in core (default outputs to disk):
$parser->output_to_core(1);

### Output each message body to a one-per-message directory:
$parser->output_under("/tmp");

### Output each message body to the same directory:
$parser->output_dir("/tmp");

### Change how nameless message-component files are named:
$parser->output_prefix("msg");

Examples of error recovery

### Normal mechanism:
eval { $entity = $parser->parse(*STDIN) };
if ($@) {
$results = $parser->results;
$decapitated = $parser->last_head; ### get last top-level head
}

### Ultra-tolerant mechanism:
$parser->ignore_errors(1);
$entity = eval { $parser->parse(*STDIN) };
$error = ($@ || $parser->last_error);

### Cleanup all files created by the parse:
eval { $entity = $parser->parse(*STDIN) };
...
$parser->filer->purge;

Examples of parser options

### Automatically attempt to RFC-1522-decode the MIME headers?
$parser->decode_headers(1); ### default is false

### Parse contained "message/rfc822" objects as nested MIME streams?
$parser->extract_nested_messages(0); ### default is true

### Look for uuencode in "text" messages, and extract it?
$parser->extract_uuencode(1); ### default is false

### Should we forgive normally-fatal errors?
$parser->ignore_errors(0); ### default is true
Miscellaneous examples
### Convert a Mail::Internet object to a MIME::Entity:
@lines = (@{$mail->header}, "n", @{$mail->body});
$entity = $parser->parse_data(@lines);