littleball

setup bind on Macbook

2009-07-26T01:08:00.000-07:00

A few things to remember before we start...
Capitalization is important!
Terminal commands are shown in orange, and preceded by a # prompt character (don't type that!).
Comments are shown below commands, and /* surrounded by comment markers */. Don't type the comments.
Text you should be pasting is in orange italics.
And now, the step-by-step...
Start a root Terminal session

Open a Terminal session and launch a root shell by typing sudo bash. The rest of the instructions assume every step is done in this root shell!

Set up your machine to run the BIND server.
# rndc-confgen > /etc/rndc.conf
/* creates rndc.conf and generates key */
# head -n 6 /etc/rndc.conf > /etc/rndc.key
/* parses the key into the proper file */
# pico -w /etc/named.conf
/* opens the BIND configuration file for editing in the text editor */
Add the following into the options section, where x.x.x.x represents the IP addresses of either your ISP, or other DNS servers, known to you (Google for DNS servers if you don't know of any):
forwarders {
x.x.x.x;
x.x.x.x;
};
Save the file and quit the editor. Hit Control-O, Enter, then Control-X.

Create StartupItem for DNS [10.4 only; otherwise jump to next step]

It seems as if Tiger has removed the (already disabled in Panther) DNS Server completely from StartupItems. We have to add it if running Tiger.
# cd /System/Library/StartupItems
# mkdir BIND
# cd BIND
# touch BIND; pico -w BIND
/* Create first of two files, then open it in text editor */
Copy the following into the file, save it, and exit:
#!/bin/sh

. /etc/rc.common

if [ "${DNSSERVER}" = "-YES-" ]; then
ConsoleMessage "Starting BIND DNS Server"
/usr/sbin/named
fi
$ touch StartupParameters.plist; pico -w StartupParameters.plist
/* Create and open second of two files needed */
Copy the following into the file,save it, and exit:
{
Description = "Local Caching DNS Server";
Provides = ("DNS Server");
OrderPreference = "None";
Messages =
{
start = "Starting BIND DNS Server";
stop = "Stopping BIND DNS Server";
};
}
$ chmod +x BIND
/* Make the script executable so it can actually be run */
Enable DNS on boot
# pico -w /etc/hostconfig
/* Open the file OS X reads to start services */
Change it to make DNSSERVER=-YES-. Here Tiger users will have to add this value; Panther users will simply change it to -YES-. Save the file and exit.

Finish up with root
# exit
/* End root shell */
Tell OS X to use your local DNS

Open System Preferences, then the Network preferences panel. Change your 'DNS Server' setting to 127.0.0.1 for all the connections you use. This step is crucial, as failing to do so will make all your hard work completely useless.

Finally, either reboot, or issue the following command in the terminal:
$ sudo /System/Library/StartupItems/BIND/BIND

libss7 and asterisk

2009-03-31T08:21:00.000-07:00

(1)svn co http://svn.digium.com/svn/libss7/tags/1.0.2 libss7-1.0.2
(2)svn co http://svn.digium.com/svn/dahdi/linux/tags/2.1.0.4 dahdi-2.1.0.4
(3)svn co http://svn.digium.com/svn/asterisk/branches/1.6.0.6 asterisk-1.6.0.6
(4)svn co http://svn.digium.com/svn/dahdi/tools/tags/2.1.0.2 dahdi-tools-2.1.0.2

Asterisk LibSS7 Howto

2009-03-26T06:10:00.000-07:00

Asterisk LibSS7 Howto

This Howto has been contributed by Matthew Fredrickson - Author of LibSS7 at Digium

I have received many requests lately for a more current document
describing how to setup Asterisk with SS7 support. The following email
will hopefully suffice. The contents of this are also contained in the
README file in libss7 as well as inside Asterisk-trunk in the
doc/ss7.txt file.

To Use:
=======
In order to use libss7, you must get at least the following versions of
Zaptel, libss7, and Asterisk (you might also want to get libpri):
Zaptel: 1.4.x
Asterisk: trunk
libss7: trunk (currently, there *only* is a trunk release).

You must then do a `make; make install` in each of the directories that
you installed in the given order (Zaptel first, libss7 second, and
Asterisk last).

NOTE: In order to check out the code, you must have the subversion
client installed. This is how to check them out from the public
subversion server.

These are the commands you would type to install them:

`svn co http://svn.digium.com/svn/zaptel/branches/1.4 zaptel-1.4`
`cd zaptel-1.4`
`make; make install`

`svn co http://svn.digium.com/svn/libss7/trunk libss7-trunk`
`cd libss7-trunk`
`make; make install`

`svn co http://svn.digium.com/svn/asterisk/trunk asterisk-trunk`
`cd asterisk-trunk`
`./configure; make; make install;`

This should build Zaptel, libss7, and Asterisk with SS7 support.

In the past, there was a special asterisk-ss7 branch to use which
contained the SS7 code. That code has been merged back into the trunk
version of Asterisk, and the old asterisk-ss7 branch has been deprecated
and removed. If you are still using the asterisk-ss7 branch, it will
not work against the current version of libss7, and you should switch to
asterisk-trunk instead.

CONFIGURATION:
In zaptel.conf, your signalling channel(s) should be a "dchan" and your
bearers should be set as "bchan".

In the asterisk-ss7 branch, there is a sample zapata.conf that is
installed which contains sample configuration for setting up an E1 link.

In brief, here is a simple ss7 linkset setup:

signalling = ss7
ss7type = itu ; or ansi if you are using an ANSI link

linkset = 1 ; Pick a number for your linkset identifier in
; zapata.conf

pointcode = 28 ; The decimal form of your point code. If you
; are using an
; ANSI linkset, you can use the xxx-xxx-xxx
notation for
; specifying your linkset pointcode.
adjpointcode = 2 ; The point code of the switch adjacent to your
; linkset

defaultdpc = 3 ; The point code of the switch you want to send
; your ISUP
; traffic to. A lot of the time, this is the
; same as your
; adjpointcode.

; Now we configure our Bearer channels (CICs)

cicbeginswith = 1 ; Number to start counting the CICs from. So if
; Zap/1 to Zap/15 are CICs 1-15, you would set
; this to 1 before you
; declare channel=1-15

channel=1-15 ; Use Zap/1-15 and assign them to CICs 1-15

cicbeginswith = 17 ; Now for Zap/17 to Zap/31, they are CICs 17-31
; so we initialize
; cicbeginswith to 17 before we declare those
; channels

channel = 17-31 ; This assigns CICs 17-31 to channels 17-31

signchan = 16 ; This is where you declare which Zap channel is
; your signalling
; channel. In our case it is Zap/16. You can
; add redundant
; signalling channels by adding additional
; sigchan= lines.

; If we want an alternate redundant signalling channel add this

sigchan = 48 ; This would put two signalling channels
in our ; linkset, one at Zap/16 and one at Zap/48 which
; both would be used to send/receive
; ISUP traffic.

; End of zapata.conf

This is how a basic linkset is setup. For more detailed zapata.conf SS7
config information as well as other options available for that file, see
the default zapata.conf that comes with the samples in asterisk. If you
would like, you can do a `make samples` in your asterisk-trunk directory
and it will install a sample zapata.conf for you that contains more
information about SS7 setup.

how to configure postgresql for asterisk cdr

2008-10-26T06:32:00.001-07:00

./configure --with-postgres=/usr/local/pgsql

SIP Strict versus Loose Routing

2008-10-12T02:22:00.001-07:00

The way how record routing works has evolved. Record routing according to RFC2543 rewrote the Request-URIii. That means the Request-URI always
contained URI of the next hop (which can be either next proxy server which inserted Record-Route header field or destination user agent). Because of that it was necessary to save the original Request-URI as the last Route header field. This approach is called strict routing.

Loose routing, as specified in RFC3261, works in a little bit different way. The Request-URI is no more overwritten, it always contains URI of the destination user agent. If there are any Route header field in a message, than the message is sent to the URI from the topmost Route header field. This is significant change--Request-URI doesn't necessarily contain URI to which the request will be sent. In fact, loose routing is very similar to IP source routing.

Because transit from strict routing to loose routing would break backwards compatibility and older user agents wouldn't work, it is necessary to make loose routing backwards compatible. The backwards compatibility unfortunately adds a lot of overhead and is often source of major problems.

SIP layered protocol

2008-10-11T01:39:00.000-07:00

(1)The lowest layer of SIP is its syntax and encoding. Its encoding is specified using an augmented Backus-Naur Form grammar (BNF).
(2)The second layer is the transport layer.
(3)The third layer is the transaction layer.
(4)The layer above the transaction layer is called the transaction user(TU). Each of the SIP entities, except the stateless proxy, is a transaction user.

SIP Record-Route

2008-10-10T23:06:00.000-07:00

In some cases, it may be useful for proxies in the SIP signaling path to see all the messaging between the endpoints for the duration of the session.

For example, if the biloxi.com proxy server wished to remain in the SIP messaging path beyond the initial INVITE, it would add to the INVITE a required routing header field known as Record-Route that contained a URI resolving to the hostname or IP address of the proxy.

This capability is frequently used for proxies that are providing mid-call features.

A route set is a collection of ordered SIP or SIPS URI which represent a list of proxies that must be traversed when sending a particular request. A route set can be learned, through headers like Record-Route, or it can be configured.

SIP Via vs Contact

2008-10-10T21:26:00.000-07:00

While the Via header field tells other elements where to send the response, the Contact header field tells other elements where to send future requests.

SIP dialog

2008-10-10T21:20:00.000-07:00

http://tools.ietf.org/rfc/rfc3261.txt

A dialog is a peer-to-peer SIP relationship between two UAs that persists for some time. A dialog is established by SIP messages, such as a 2xx response to an INVITE request. A dialog is identified by a call identifier, local tag, and a remote tag. A dialog was formerly known as a call leg in RFC 2543.

The combination of the To tag, From tag, and Call-ID completely defines a peer-to-peer SIP relationship between caller and callee and is referred to as a dialog.

netbeans java.lang.AbstractMethodError: org. customer .xerces.dom.DeferredDocumentImpl.setDocumentURI(Ljava/lang/String;)V

2008-06-06T22:08:00.000-07:00

Context:

when running Netbeans under JDK 1.5.X or later, when one jsp file is opened and being saved, following exception is thrown:

java.lang.AbstractMethodError: org. customer.xerces.dom.DeferredDocumentImpl.setDocumentURI(Ljava/lang/String;)V

o make a long story short:

- Method
public void setDocumentURI(String documentURI);
was added to the org.w3c.dom.Document interface
in J2SE 1.5 (it was not present in J2SE 1.4).

- The new method is implemented by
com.sun.org.apache.xerces.internal.dom.DeferredDocumentImpl
(in J2SE 1.5), but not by
org.apache.xerces.dom.DeferredDocumentImpl
in xercesImpl.jar

- javax.xml.parsers.DocumentBuilderFactory in J2SE 1.5 will instantiate
factories of type "org.apache.xerces.jaxp.DocumentBuilderFactoryImpl"
for webapps bundling xercesImpl.jar, due to the presence of the
META-INF/services/javax.xml.parsers.DocumentBuilderFactory resource
in that JAR, which specifies
"org.apache.xerces.jaxp.DocumentBuilderFactoryImpl" as the factory
type to be instantiated.

Instructing the WebappClassLoader to avoid loading any symbols from
"org.apache.xerces" (and hoping it would fallback to
"com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl")
won't solve the problem.

I've arrived at a fix, which is to define a system property with name

javax.xml.parsers.DocumentBuilderFactory

and specify

com.sun.org.apache.xerces.internal.jaxp.DocumentBuilderFactoryImpl

as its value.

How to use STUN in applications

2008-05-25T20:03:00.000-07:00

How to use STUN in applications

This document has been reviewed for maemo 3.x.

This tutorial shows how to use the libjingle API to create peer-to-peer connections between parties that are behind NAT routers.
Network Address Translation (NAT)

NAT routers were born because of the imminent IP address exhaustion. The currently most used Internet address, called IPv4, is 32 bits wide, which means around 4 billion address available.

4 billion addresses seem to be an abundant resource, but not all addresses can be assigned to hosts, as not all telephone number permutations can be assigned to users, since IP addresses also carry routing information, analog to the prefix of a telephone number that identifies country, region, city...

The definitive solution for the problem is to increase the address length, that is what IPv6 does, by offering 128-bit addresses. But IPv6 would take (and it is taking) time to be deployed, so an intermediate solution was found: NAT - Network Address Translation.

A NAT router acts like a switchboard between the public Internet and a private network. The NAT router needs to have at least one valid Internet address in order to be "seen" by the rest of the Internet. The computers in the private network have private address in the ranges 10.0.0.0/8, 192.168.0.0/16 or 172.16.0.0/12, that are not routable in the Internet.

When a private computer e.g. address 10.0.0.1 tries to connect a public server e.g. 200.215.89.79, the network packet must pass through the NAT router. The NAT router knows that the source address 10.0.0.1 is not routable. So the NAT router replaces 10.0.0.1 with its own valid address (e.g. 64.1.2.3) and sends the packet forward.

The remote server 200.215.89.79 will "see" a connection coming from the 64.1.2.3 host, and will reply to that host.

When the response packet comes to NAT router, it must know somehow that this packet is not for itself, it is for the computer in the private network. Once the NAT router relates the packet coming from the blue with the active NAT'ed connections, it can replace the destination address from 64.1.2.3 to 10.0.0.1 and deliver the packet in the private network.

In more technical depth, NAT is possible because absolutely every network connection in the Internet has a unique tuple built from the following values:

* Client address (the host that initiates the connection)
* Server address (the passive side that receives the initiation packet)
* Client port number
* Server port number
* The transport protocol e.g. TCP, UDP, SCTP...

If the NAT router replaces the client address by its own, but also replaces the client port number when necessary to avoid clash with another active connection, the uniqueness of each connection is not broken. NAT allows for a virtually unlimited number of computers in a private network to access the Internet via only one NAT router with only one public IP address.
NAT problems

NAT is not without some disvantages. First, the NAT router needs to keep connection states in memory, which partially denies a cornerstone Internet philosophy ("dumb routers, smart hosts"). If a NAT router is reset, all connections will be terminated, while a regular router could be reset without harming any connection.

Second, the hosts in private network cannot easily offer a service to the public Internet, that is, these hosts cannot be the "passive" side in connections, since the initiation packet will come to the NAT router and it will have no related connection in its memory.

A partial solution for that problem is to open a "hole" in the NAT for specific ports, for example any connection to the port 8000 of the NAT router should be redirected to the machine 10.0.0.2 port 80. That works, but it does not scale (the number of ports is limited, and some protocols work only on a very specific port number) and demands configuring the NAT router.

Since the bulk of the Internet traffic is HTTP and initiated from the private network, NATs are fine for most users.
NAT peer-to-peer circumvention techniques

The most problematic services to deploy in presence of NATs are of peer-to-peer (P2P) style, when two clients of the service make direct connections to each other, without sending data through an intermediate server. This is the case of SIP-based VoIP, most P2P file sharing networks etc.

If one of the P2P parties has a routable IP address, the problem is solved: the party behind the NAT router must initate the connection, and that's it. The remaining problematic case (unfortunately the most common one) is when both P2P parties are behind NATs.

Several techniques have been proposed to solve this case. The most elegant solutions require both software updates in the NAT router itself and explicit support in the client software. It is the case of UPnP IGD (Internet Gateway Device) protocol, where a host can explicitely request a "hole" to be open in the NAT router, so a service is acessible from the Internet.

IGD is nice and has been enjoying good support from NAT router vendors, but it is still not ubiquitous and has a major flaw: if there are two or more NAT routers in the packet traffic way (a rather common situation), IGD ceases to be effective.

It is opportune to remember that none of the NAT circumvention techniques, not even the most elegant, solve completely the problem. There still must be a signaling protocol for the parties to exchange the connection parameters. In other words, It does not suffice to be able to open a "hole" in the NAT router; there must be a way to communicate the address and port of the hole to the remote party. A pure P2P service can only be achieved when all parties possess public addresses, which is expected to happen when IPv6 is widely deployed.

Another way is simply to open a NAT hole via router configuration. Most home/SOHO routers allow this configuration to be easily done. It is a very popular technique among gamers (some routers even label the NAT holes as "game ports"). The main advantage of this technique is no need of explicit NAT-piercing support in the client software itself. The software must only be "well-behaved", not trying to guess the local IP address by itself (which would return a private address instead of the router public address).

The main disvantage of manual configuration of NAT holes is that they are, well, manual: one explicit administrative intervention is needed for each new protocol. It it not good enough if the user has no access to NAT configuration (the most common case in collective and corporate networks).
STUN, TURN and ICE protocols

There have been proposed NAT circumvention techniques that do not demand router software updates. STUN (Simple Transversal of UDP through NATs) is the main one. STUN exploits the connectionless nature of UDP, as well as a security weakness of some NAT implementations. The technique is bound to UDP features, so STUN can not be used for e.g. TCP connections.

The STUN protocol demands a STUN server with a well-known public IP address in the Internet. STUN stores the private address/port in an UDP payload and sends the packet to the STUN server. If packet goes through a NAT router, the address/port will be changed in the IP header -- but not in the payload.

By comparing the payload with the IP header, and sending back the results to the client, STUN can deduce if there are any NAT routers in the way. If there are none, the host knows that it can directly receive connections from parties behind NATs.

Some NATs have poor implementations that, in conjunction with STUN, allow for incoming UDP flow. The "full cone" NAT always translates the same source address/source port tuple to the same NAT router port; this relieves the NAT from storing full connection state. Any packet coming from Internet to that router port will be delivered to the host in the private network, no matter it came from.

This allows for the private host to easily "punch a hole" in the NAT router. The first packet that opens the hole goes to STUN server. In turn, the private host learns from the STUN server which is the IP address and port number of the hole. These parameters are sent to the remote peer via signaling protocol. The remote peer can then send UDP data directly.

Unfortunately, most NAT routers are not that naive; they are "symmetric", that is, they store full connection state and do not allow incoming packets from anyone but the party that was first contacted (in our case, the STUN server). In this scenario, STUN is not enough to allow P2P communication in presence of NAT.

TURN (Traversal Using Relay NAT) comes for the rescue. TURN employs the same protocol as STUN, but the TURN server acts as a relayer in which both parties behind NATs can connect to. Since the relay server adds latency and needs to be maintained (and its bandwidth costs money), TURN should be used only as a last resort.

ICE (Interactive Connectivity Establishment), a draft specification that is employed by Google Talk, is not a protocol by itself; it is a collection of techniques like STUN and TURN that finds all possible ways to establish a P2P connection and selects the best one.

ICE works by finding all possible P2P connection candidates and sending this data to the remote peer via a signaling protocol (which is not specified by ICE, so the mechanism can be employed by any existing signaling protocol). Both parties do that simultaneously, so there are candidate messages flowing in both directions. When the parties agree on the best way to make the P2P connection, they can begin to exchange data directly.

The biggest advantage of STUN, TURN and ICE is that they do not depend on specific support by the NAT routers, and ICE will work even if there are several routers in the network path. The downside is the need of public STUN and TURN (relay) servers. This disvantage is dilluted to some extent by the fact that every P2P service demands a signaling server anyway, so the same entity that offers the signaling will certainly offer the auxiliary STUN/TURN services.

Another minor disvantage of ICE is that the signaling protocol will have to accomodate the "connection candidate" message, either by a explicit provision in the protocol (e.g. XMPP) or by some kludge.
NAT transversal API in maemo

In maemo platform, the developer does not need to worry about protocols or anything. maemo includes the libjingle library (the same as Google Talk) which offers an API for P2P connections.

Nothing better than living examples to show how the maemo developer can take advantage on this API. Our example P2P client is very simple: it requests a service at random times and also processes requests from other P2P clients. The "service" is nothing more than adding 2 byte values.

As already stated, every P2P server must have a signaling protocol over which the parties can exchange initial P2P connection parameters, so we need to build a very simple server as well as the signaling protocol. Since it is just an example, our server architecture does not attribute IDs for the clients, and therefore can handle only two simultaneous clients.

The signaling protocol is very simple and has only one message: the connection candidate that one peer sends to the other. The message is simply forwarded to the other peer. Apart from encoding/decoding, these messages are completely handled by libjingle, so we don't need to understand them in depth.

Once the connection parameters have been exchanged via the signaling server, the P2P connection happens and the parties communicate directly without any further signaling. Albeit very simple, this protocol simulates all the basic steps of every real-world P2P service.

If you are interested in using XMPP/Google Talk as the signaling service, Libjingle source also contains examples of P2P communication that employ XMPP/Google Talk accounts and servers.
Example: P2P client

Follows a C++ example of P2P client based on Libjingle APIs. It is the smallest possible demonstration of NAT-piercing capability, so it does not handle network errors and overflows very well. A production implementation must improve in these directions.

First, there is some boilerplate code: includes and prototypes.

#define POSIX
#define SIGSLOT_USE_POSIX_THREADS

#include

#include
#include
#include
#include
#include
#include

#include

#include
#include

#include
#include

#include
#include
#include
#include
#include
#include

#include

void signaling_init(const char* ip, unsigned int port);
int signaling_wait(unsigned int timeout);
void signaling_sendall(const char* buffer, unsigned int len);

SocketClient* socketclient_init(const char *stun_ip, unsigned int stun_port,
const char *turn_ip, unsigned int turn_port);

char* socketclient_add_remote_candidates(SocketClient *sc, char* buffer);
void socketclient_add_remote_candidate(SocketClient *sc, const char *candidate);

bool socketclient_is_writable (SocketClient *sc);

void socketclient_send(SocketClient *sc, const char *data, unsigned int len);

void randomize();

For the sake of simplicity, we keep some data in global variables. A production implementation would probably move those data into objects.

The p2p_state shows whether the P2P connection is up or down. signaling_socket is a TCP socket that allows data exchange via the signaling server before the P2P connection is up. main_thread contains a libjingle's Thread object; libjingle is itself multithreaded and employs one thread per P2P connection.

bool p2p_state = false;
int signaling_socket = -1;

cricket::Thread *main_thread = 0;

This is the main program loop. It sets up the signaling connection, forwards signaling data to LibJingle until the P2P connection is up. The P2P connection is simply used to send bytes at random intervals. If the P2P connection breaks, the loop returns to signaling phase. The program only stops when killed or when some unexpected error occurs.

Note that we call main_thread->Loop(10) from time to time. In a "real" application, we would have this method called on idle time (e.g. via GLib's g_idle_add().

We have some IP addresses hardcoded: signaling server, STUN server (if any) and TURN server (if any). Please update those addresses for your particular environment.

int main(int argc, char* argv[])
{
signal(SIGPIPE, SIG_IGN);
randomize();

// P2P signaling server
const char* signaling_ip = "200.184.118.140";
int signaling_port = 14141;

// STUN server if any, set to NULL if there are none
const char* stun_ip = "200.184.118.140";
// const char* stun_ip = 0;
unsigned int stun_port = 7000;

// TURN server if any, set to NULL if there are none
const char* turn_ip = "200.184.118.140";
// const char* turn_ip = 0;
unsigned int turn_port = 5000;

signaling_init(signaling_ip, signaling_port);

SocketClient* sc = socketclient_init(stun_ip, stun_port, turn_ip, turn_port);

sc->getSocketManager()->StartProcessingCandidates();

while (1) {
char buffer[10000];
char *buffer_p = buffer;
char *buffer_interpreted = buffer;

while (! p2p_state) {
main_thread->Loop(10);

if (! signaling_wait(1)) {
printf("-- tick --\n");
continue;
}

int n = recv(signaling_socket, buffer_p, sizeof(buffer) - (buffer_p - buffer), 0);
if (n < 0) {
printf("Signaling socket closed with error\n");
exit(1);
} else if (n == 0) {
printf("Signaling socket closed\n");
exit(1);
}
buffer_p += n;
buffer_interpreted = socketclient_add_remote_candidates(sc, buffer_interpreted);
}

// P2P connection is up by now.

while (p2p_state) {
// sends a byte via P2P connection
unsigned char data = random() % 256;
socketclient_send(sc, (char*) &data, 1);
sleep(random() % 15 + 1);
main_thread->Loop(10);
}

// P2P connection is broken, restart handling connection candidates
}
}

Seeds the random() with some "random" value, otherwise the two peers may end up with exactly the same bytes and time intervals during P2P data exchange.

void randomize()
{
struct timeval tv;
struct timezone tz;
gettimeofday(&tv, &tz);
srandom(tv.tv_usec);
}

This function creates the signaling socket -- just a boring and ordinary TCP connection to the P2P signaling server.

void signaling_init(const char* ip, unsigned int port)
{
struct sockaddr_in sa;

signaling_socket = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);

bzero(&sa, sizeof(sa));
sa.sin_family = AF_INET;
sa.sin_port = htons(port);
inet_aton(ip, &(sa.sin_addr));

if (connect(signaling_socket, (struct sockaddr*) &sa, sizeof(sa)) < 0) {
printf("Error in signaling connect()\n");
exit(1);
}
}

This function waits for something to happen with the singaling socket, until the specified timeout. It is important that the timeout is not too large, since the P2P connection may have been brought up meanwhile.

int signaling_wait(unsigned int timeout) {
fd_set rfds;
struct timeval tv;
int retval;

FD_ZERO(&rfds);
FD_SET(signaling_socket, &rfds);

tv.tv_sec = timeout;
tv.tv_usec = 0;

retval = select(signaling_socket+1, &rfds, NULL, NULL, &tv);
if (retval == -1)
printf("error in select()");

return (retval > 0);
}

Libjingle is C++ and employs a signal architecture to notify the client application about changes in P2P connection status. These two classes accomodate the methods that will be called back when something happens.

Since we are not using XMPP as the signaling protocol, we need to provide the signaling protocol handling by ourselves, so all signaling handling is carried out separatedly from those signals.

class SignalListener1 : public sigslot::has_slots<>
{
private:
SocketClient *sc;

public:
SignalListener1(SocketClient *psc);
void OnCandidatesReady(const std::vector& candidates);
void OnNetworkError();
void OnSocketState(bool state);
};

class SignalListener2 : public sigslot::has_slots<>
{
private:
SocketClient *sc;

public:
SignalListener2(SocketClient *psc);
void OnSocketRead(P2PSocket *socket, const char *data, size_t len);
};

SignalListener1::SignalListener1(SocketClient* psc)
{
sc = psc;
}

SignalListener2::SignalListener2(SocketClient* psc)
{
sc = psc;
}

void SignalListener1::OnNetworkError()
{
printf ("Network error encountered at SocketManager");
exit(1);
}

The first signal callback method. It is called when the P2P socket changes state. We update the p2p_state global variable with the reported state, and this will drive our main loop behavior.

void SignalListener1::OnSocketState(bool state)
{
printf("Socket state changed to %d\n", state);
p2p_state = state;
if (state) {
printf("Writable from %s:%d to %s:%d\n",
sc->getSocket()->best_connection()->local_candidate().address().IPAsString().c_str(),
sc->getSocket()->best_connection()->local_candidate().address().port(),
sc->getSocket()->best_connection()->remote_candidate().address().IPAsString().c_str(),
sc->getSocket()->best_connection()->remote_candidate().address().port());
}
}

This function packages all P2P socket creation bureaucracy. It creates the socket object, the socket listeners (whose classes have been defined above by us) and connects the signal callbacks.

SocketClient* socketclient_init(const char *stun_ip, unsigned int stun_port,
const char *turn_ip, unsigned int turn_port)
{
cricket::SocketAddress *stun_addr = NULL;
if (stun_ip) {
stun_addr = new cricket::SocketAddress(std::string(stun_ip), stun_port);
}

cricket::SocketAddress *turn_addr = NULL;
if (turn_ip) {
turn_addr = new cricket::SocketAddress(std::string(turn_ip), turn_port);
}

cricket::PhysicalSocketServer *ss = new PhysicalSocketServer();
main_thread = new Thread(ss);
cricket::ThreadManager::SetCurrent(main_thread);

SocketClient *sc = new SocketClient (stun_addr, turn_addr);

// Note that signal connections pass the SignalListener1 object as well as the
// method. Since a new SocketListener1 is created for every new SocketClient,
// we have the guarantee that each SocketListener1 will be called back only
// in behalf of its related SocketClient.

sc->sigl1 = new SignalListener1(sc);
sc->sigl2 = new SignalListener2(sc);
sc->getSocketManager()->SignalNetworkError.connect(sc->sigl1, &SignalListener1::OnNetworkError);
sc->getSocketManager()->SignalState_s.connect(sc->sigl1, &SignalListener1::OnSocketState);
sc->getSocketManager()->SignalCandidatesReady.connect(sc->sigl1, &SignalListener1::OnCandidatesReady);
sc->CreateSocket(std::string("foobar"));
sc->getSocket()->SignalReadPacket.connect(sc->sigl2, &SignalListener2::OnSocketRead);

return sc;
}

This method is called back when LibJingle has some local candidates for connection, that should be sent to the remote site via the signaling protocol.

The beauty of ICE protocol is that parties will be able to agree on a P2P connection without having to exchange request/response messages. They just send connection candidates to each other. Each side selects the "best" way to send data based on received candidades; being both sides able to send data directly to the remote party, we have a P2P bidirectional channel.

void SignalListener1::OnCandidatesReady(const std::vector& candidates)
{
printf("OnCandidatesReady called with %d candidates in list\n", candidates.size());

for(std::vector::const_iterator it = candidates.begin(); it != candidates.end(); ++it) {
char *marshaled_candidate;

asprintf(&marshaled_candidate, "%s %d %s %f %s %s %s\n",
(*it).address().IPAsString().c_str(), (*it).address().port(), (*it).protocol().c_str(),
(*it).preference(), (*it).type().c_str(), (*it).username().c_str(),
(*it).password().c_str() );

printf("Candidate being sent: %s", marshaled_candidate);

signaling_sendall(marshaled_candidate, strlen(marshaled_candidate));

free(marshaled_candidate);

}
}

An auxiliary function to send a data buffer through the signaling TCP channel. It does not return until all data has been sent.

void signaling_sendall(const char* buffer, unsigned int len)
{
unsigned int sent = 0;
while (sent < len) {
int just_sent;
just_sent = send(signaling_socket, buffer+sent, len-sent, 0);
if (just_sent < 0) {
printf("Signaling socket closed with error.\n");
exit(1);
} else if (just_sent == 0) {
printf("Signaling socket closed.\n");
exit(1);
}
sent += just_sent;
}
}

This function is called by the main loop when some signaling data arrives. It will find out if there is a complete P2P connection candidate in the buffer. If there is one, it is decoded.

// extracts remote candidates from a buffer, returns a pointer to the rest of the buffer

char* socketclient_add_remote_candidates(SocketClient *sc, char* buffer)
{
char *n;
char candidate[1024];

while (1) {
n = strchr(buffer, '\n');
if (! n) {
return buffer;
}
strncpy(candidate, buffer, n-buffer+1);
socketclient_add_remote_candidate(sc, candidate);
buffer = n+1;
}
}

Here, the P2P connection candidate is decoded and made known to LibJingle. Since LibJingle has its own thread and sockets, all further processing of P2P candidates is fortunately outside the scope of our code.

// Inform candidates received from the signaling network to LibJingle

void socketclient_add_remote_candidate(SocketClient *sc, const char* remote_candidate)
{
std::vector candidates;

char ip[100];
unsigned int port;
char protocol[100];
float preference;
char type[100];
char username[100];
char password[100];

// WARNING: using fixed-size buffers and sscanf is utterly unsafe.
// Real implementations must be more robust about data coming from the network!

sscanf(remote_candidate, "%s %d %s %f %s %s %s\n", ip, &port, protocol, &preference, type, username, password);

printf("Received new candidate: %s:%d pref %f\n", ip, port, preference);

Candidate candidate;
candidate.set_name("rtp");
candidate.set_address(SocketAddress(std::string(ip), port));
candidate.set_username(std::string(username));
candidate.set_password(std::string(password));
candidate.set_preference(preference);
candidate.set_protocol(protocol);
candidate.set_type(type);
candidate.set_generation(0);

candidates.push_back(candidate);

sc->getSocketManager()->AddRemoteCandidates(candidates);
}

Simple helper function that shows whether a P2P socket is writable (which means that the P2P connection is up).

bool socketclient_is_writable(SocketClient *sc)
{
return sc->getSocketManager()->writable();
}

Method that is called back when data arrives from the P2P connection. In our example, it is just a byte of data.

void SignalListener2::OnSocketRead(P2PSocket *socket, const char *data, size_t len)
{
printf("Received byte %d from remote P2P\n", data[0]);
}

Auxiliary function that sends data via P2P connection. Not really difficult.

void socketclient_send(SocketClient* sc, const char *data, unsigned int len)
{
sc->getSocket()->Send(data, len);
printf("Sent byte %d to remote P2P\n", data[0]);
}

The signaling server

As already said, our signaling server is incredibly simple and works more like a network pipe, forwarding data from one side to another. The P2P parties ogree on a P2P connection through this channel.

from select import select
import socket
import time

read_socks = []
port = 14141

server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server_sock.bind(("", port))
server_sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server_sock.listen(5)

read_socks.append(server_sock)

# We accept two parties only
buffer = ""

while True:
rd, wr_dummy, ex_dummy = select(read_socks, [], [], 10)

if not rd:
print "-- tick --"

continue

rd = rd[0]

if rd is server_sock:
# incoming new connection
newsock, address = rd.accept()
print "New connection from %s" % str(address)
if len(read_socks) > 3:
# we only accept two parties at the most
newsock.close()
continue
read_socks.append(newsock)
if buffer:
# we already have data to be sent to the new party
newsock.sendall(buffer)
print " sent buffered data"
buffer = ""
continue

data = rd.recv(999999)

if not data:
# socket closed, remove from list
print "Connection closed"

del read_socks[read_socks.index(rd)]
buffer = ""
continue

if len(read_socks) < 3:
print "Buffering data"
# the other party has not connected; bufferize
buffer += data
continue

print "Forwarding data"
for wr in read_socks:
if wr is not rd and wr is not server_sock:
wr.sendall(data)

STUN and relay servers

The maemo libjingle-utils package includes both a STUN server and a relay server for testing purposes. To run a test server, do the following:

$ stunserver &

$ relayserver &

The relay server will print console messages when a P2P connection is flowing through it. If you need more detailed feedback (e.g. if you are debugging a P2P application), use a network sniffing tool like tcpdump or Ethereal to monitor UDP packets.

reboot linux

2008-05-21T07:13:00.000-07:00

Context: CentOS 5. Postgresql data directory is locked and cannot reboot the server by $reboot

Solution:

$echo 1 > /proc/sys/kernel/sysrq
$echo b > /proc/sysrq-trigger

Above two commands will reboot the server.

Using NowSMS as an MMSC in CDMA or CDMA2000 Environments

2008-04-04T17:55:00.001-07:00

Delivering MMSC functionality in an CDMA or CDMA2000 environment can be challenging because the original WAP specifications for CDMA have technical requirements that require additional SMSC functionality.

(Technical note: CDMA2000 is different from WCDMA. CDMA2000 is an evolutionary upgrade path from CDMA. By contrast, WCDMA is an evolutionary upgrade from GSM/GPRS. CDMA2000 builds upon technical standards already deployed for CDMA, while WCDMA/UMTS builds upon technical standards already deployed for GSM/GPRS.)

MMS Message Notifications are generally sent via WAP Push over WDP (Wireless Datagram Protocol) over SMS. (It is also possible to deliver WAP Push over WDP over IP, but this is generally not practical unless there is an accessible database lookup for phone number to IP address translation. NowSMS currently can facilitate this IP only scenario, but in a way that is only suitable for test lab environments. This capability is described in a separate technical bulletin, and is outside of the scope of this bulletin.)

When a WAP Push message is larger than the network size limit for SMS (140 bytes in a GSM environment, and somewhat variable in CDMA environments), the WAP Push message must be segmented to enable it to be sent over multiple SMS messages.

In GSM environments, User Data Header (UDH) fields have been standardised to support the necessary segmentation, and the UDH parameters for segmentation are well understood and widely supported.

In CDMA environments, no standard for segmentation exists. Therefore, the WAP Forum defined its own standard for the sending of segmented WDP messages in a CDMA environment.

A key requirement of this standard is that each segment of the message must use the same CDMA SMS message id. However, the CDMA SMS message id field is a value that is generated by the SMSC, and cannot be set by an application that is submitting messages to the SMSC, such as an MMSC or WAP Push Proxy Gateway.

The authors of the WAP specification anticipated this limitation and defined a standard for WDP Adaptation over SMPP (WAP-159-WDPWCMPAdapt).

By default, NowSMS generates WAP Push messages (and MMS Notification messages which are based upon WAP Push) using a format that is specific to GSM (and WCDMA/UMTS) environments. However, there is also a configuration option defined on the "Advanced Settings" page of the SMPP configuration properties titled "Use WDP Adaptation for WAP Push and MMS Notifications (required for CDMA)". This setting is primarily used when connecting to a CDMA based SMSC. When this configuration option is enabled, NowSMS uses a protocol independent format known as "WDP Adaptation". This is usually the only practical option for delivering WAP Push messages in a CDMA environment. In this case, NowSMS will submit messages to the SMPP server using the "WAP" teleservice (SMPP service type), consistent with the WDP and WCMP Adaptation specification.

By default, even if a WAP push message is longer than 140 bytes, when this option is selected, NowSMS will deliver the complete message in a single submission to the SMSC. NowSMS then expects the SMSC to perform any necessary segmentation for delivering the message over SMS. (This expectation exists because the SMSC must use the same CDMA SMS message id for each segment of the message, and there is no place in the SMPP protocol for NowSMS to specify this message id.)

It is also possible to configure NowSMS to use segmentation for longer messages, even if WDP Adaptation is enabled by checking the "Use TLV parameters for port numbers and segmentation" option. In this case, NowSMS segments on a 140 byte boundary, the same as in GSM environments.

When configuring NowSMS in CDMA environments, segmentation issues are usually the biggest problem, because of the WAP protocol requirement that the SMSC use the same CDMA SMS message id for each segment of the message.

If you experience problems sending WAP Push and/or MMS notifications in a CDMA environment with WDP Adaptation, here are some suggestions:
WDP Adaptation (WAP-159-WDPWCMPAdapt). If you are connecting via an independent SMS provider, it is likely that they are not aware of this protocol option, but it is likely to be supported by the CDMA operator's SMSC.

Instead of troubleshooting by sending MMS messages, try sending simple WAP push messages first. Send a simple WAP push message via the NowSMS web interface (page 82), keeping the URL and text relatively short to ensure that the message can be delivered in a single segment. If that works, next try increasing the amount of text in the message. If the message delivery fails with longer WAP push messages, then you will want to take steps to limit the size of MMS notification messages that are generated by the NowSMS MMSC. This can be accomplished with the following suggestions:

1. Use the shortest possible host name (in number of characters) for the "Local Host Name or IP Address" setting of the MMSC. This host name must be included in the every MMS Notification that is generated by the MMSC. Every byte saved in the host name saves a byte in the size of the resulting notification messages.
2. If possible, use Port 80 as the "HTTP Port" for the MMSC. If a port other than port 80 is used, it must be appended to the host name when generating the URL.
3. Edit MMSC.INI, and under the [MMSC] header, add CompactMMSURL=Yes. This setting shortens the length of the dynamic path that is generated when sending MMS messages and will save a few bytes in every MMS notification with no other effect.
4. Edit MMSC.INI, and under the [MMSC] header, add MMSNotificationNoSubject=Yes. By default, NowSMS will include the message subject in the MMS Notification message. Having the subject present can help someone who has a mobile phone configured for manual message download to determine whether or not they want to download the message. However, the specification does not require the subject to be present in the notification, and omitting it can prevent long MMS notifications.
5. Edit MMSC.INI, and under the [MMSC] header, add Nokia3510Compatible=No. This setting reduces the size of the MMS notification by approximately 30 bytes, at the expense of compatibility with early model GSM MMS phones (specifically the original Nokia 3510 and Panasonic GD87). These phones did not understand the short form of MMS content type encoding in the MMS header, and required the long form. The MMS specifications do require that the handsets support the short form of this encoding, and technically these early model handsets were non-conformant. While GSM operators may want to maintain compatibility with these early model handsets, this should not be a consideration in CDMA environments.

NowSMS 2006 has also been extended to provide extensions to the HTTP SMSC interface to facilitate MMS and WAP Push in CDMA environments. This functionality is intended primarily for test lab environments (specifically with Agilent's CDMA test kit), but might also be useful for mobile operators whose SMSCs do not support WDP Adaptation.

To enable this support, define an HTTP SMSC connection in NowSMS as normal.

Next, manually edit the SMSGW.INI, and locate the [HTTP – server:port] section for this HTTP SMSC connection. Under this header, add CDMATemplateWAP=, where this is a URL template to be used for submitting WAP Push messages (MMS notifications are a special type of WAP Push). This URL template is similar to the existing text and binary templates, however you should use the @@CDMAWAPPDU@@ replacement parameter for NowSMS to insert the WAP PDU in CDMA format. (Do not use the @@TEXT@@, @@DATA@@, @@DATABIN@@ or @@UDH@@ parameters!)

By default, NowSMS will segment the CDMA WAP PDU to a size limit of 112 bytes, and issue multiple HTTP requests to submit the message in multiple segments. To change this size limit, specify CDMASizeLimit=### in the same section of the SMSGW.INI file.

An additional replacement parameter, @@CDMAWAPMMTS@@ is available. This parameter will be set to "1" for all segments except the final segment in a multiple segment WAP Push submission. This parameter will be set to "0" in a single segment WAP Push submission, and also in the final segment of a multiple segment WAP Push submission. ("MMTS" stands for "more messages to send", and is used to indicate that an additional segment will follow. This is necessary because in CDMA, the SMSC must apply the same MESSAGE_ID value to all segments of a multiple segment message.)

If the HTTP SMSC does not support the MMTS flag, then you should follow the advice that was given earlier in this bulletin regarding how to limit the size of the MMS Notification message.

Additionally, ensure that the URL template sets whatever flag is necessary to indicate that the CDMA WAP teleservice should be used.

make Nokia phone E65 as modem for SMS

2008-04-01T07:26:00.000-07:00

(1)Mac/E65
(2)Bluetooth connectivity
(3)minicom installed on Mac
(4)bluetooth standard provides modem interface. So, Making starting bluetooth makes modem available. The serial port is under /dev/tty....(Computer name)
(5)$minicom -s
setup the modem and save as "e65". Then minirc.e65 will be saved.
(6)$minicom e65, which will connect to E65 phone.
(7)Type AT commands, the phone will response properly.

pys60 TCP/IP console

2008-04-01T06:46:00.000-07:00

(1)Mac/E65/Wireless router
(2)Mac IP : 192.168.1.64
(3)on Mac run: $stty raw -echo ; nc -l -p 1025; stty sane
(4)vi btc.py file with following codes:
import btconsole
from socket import *
sock=socket(AF_INET, SOCK_STREAM)
sock.connect(("192.168.1.64",1025))
btconsole.run_with_redirected_io(sock,btconsole.interact,None,None,locals())
sock.close()

(5)bluetooth btc.py to E:\\Python folder on E65
(6)Run btc.py through pys60 shell. It will search Mac and connect to Mac console.

javascript removeChild crash IE

2007-12-08T00:03:00.000-08:00

A web page load a gwt specific javascript file (entry point).

This javascript insert a javascript (A) dynamically to invoke JSON service.
The callback of the JSON will delete the dynamically inserted javascript (A) for house cleaning.

Above "Inserting A and deleting A" will be repeated each 5 seconds.

To removeScript, following code will crash IE.

var x =document.getElementsByTagName("script");
for (var i=0;i var y=x[i];
var src = y.getAttribute("src");
if(src!=null && src.indexOf("callback")>0){
var head = document.getElementsByTagName('head').item(0);
head.removeChild(y);
y.removeNode();
return;
}
}

However, following code will work:

setTimeout(function() {
var x =document.getElementsByTagName("script");
for (var i=0;i var y=x[i];
var src = y.getAttribute("src");
if(src!=null && src.indexOf("callback")>0){
var head = document.getElementsByTagName('head').item(0);
head.removeChild(y);
y.removeNode();
return;
}
}
}, 0);

Howto: Setup a DNS server with bind

2007-11-20T19:25:00.000-08:00

Step1: Install bind 9
Step2: vi /etc/bind/named.conf.local
# This is the zone definition. replace example.com with your domain name
zone "example.com" {
type master;
file "/etc/bind/zones/example.com.db";
};

# This is the zone definition for reverse DNS. replace 0.168.192 with your network address in reverse notation - e.g my network address is 192.168.0
zone "0.168.192.in-addr.arpa" {
type master;
file "/etc/bind/zones/rev.0.168.192.in-addr.arpa";
};
And named.conf.local to named.conf
Step3:vi /etc/bind/named.conf.options
forwarders {
# Replace the address below with the address of your provider's DNS server
123.123.123.123;
};
Step4:mkdir /etc/bind/zones
Step5:vi /etc/bind/zones/example.com.db
// replace example.com with your domain name. do not forget the . after the domain name!
// Also, replace ns1 with the name of your DNS server
example.com. IN SOA ns1.example.com. admin.example.com. (
// Do not modify the following lines!
2006081401
28800
3600
604800
38400
)

// Replace the following line as necessary:
// ns1 = DNS Server name
// mta = mail server name
// example.com = domain name
example.com. IN NS ns1.example.com.
example.com. IN MX 10 mta.example.com.

// Replace the IP address with the right IP addresses.
www IN A 192.168.0.2
mta IN A 192.168.0.3
ns1 IN A 192.168.0.1
Step6: vi /etc/bind/zones/rev.0.168.192.in-addr.arpa
@ IN SOA ns1.example.com. admin.example.com. (
2006081401;
28800;
604800;
604800;
86400
)

IN NS ns1.example.com.
1 IN PTR example.com
Step7: /etc/init.d/bind9 restart
Step8: change /etc/resolv.conf
search example.com
nameserver 192.168.0.1

centos 5 iptables configure

2007-11-02T22:46:00.000-07:00

$yum install system-config-securitylevel
$system-config-securitylevel

asterisk 1.4 on centos 5 "inode diet"

2007-10-30T08:11:00.000-07:00

/*
* As part of the "inode diet" the private data member of struct inode
* has changed in 2.6.19. However, Fedore Core 6 adopted this change
* a bit earlier (2.6.18). If you use such a kernel, Change the
* following test from 2,6,19 to 2,6,18.
*/
#if LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18)
#define I_PRIVATE(inode) ((inode)->u.generic_ip)
#else
#define I_PRIVATE(inode) ((inode)->i_private)
#endif

Remote UNIX connection(disconnected) and asterisk

2007-10-19T07:48:00.000-07:00

On CLI which is under verbose output, following message will be generated every 5 seconds.

It is due to safe_asterisk process, which itself is invoked by asterisk service, that kept connecting!

> > -- Remote UNIX connection
> > -- Remote UNIX connection disconnected
> > -- Remote UNIX connection
> > -- Remote UNIX connection disconnected
> > -- Remote UNIX connection
> > -- Remote UNIX connection disconnected
> > -- Remote UNIX connection
> > -- Remote UNIX connection disconnected

gcc: installation problem, cannot exec `cc1plus': No such file or directory

2007-10-13T18:36:00.000-07:00

$yum install gcc-c++

list bios information on linux

2007-10-10T07:41:00.000-07:00

$dmidecode

dmidecode is a tool for dumping a computer’s DMI (some say SMBIOS) table contents in a human-readable format

pci device profile

2007-10-10T07:15:00.001-07:00

On linux,

$lspci -tv show the tree map of the pci device

Simple Linux network traffic monitor

2007-10-08T06:43:00.000-07:00

vnStat is a network traffic monitor for Linux that keeps a log of daily network traffic for the selected interface(s). vnStat isn't a packet sniffer. The traffic information is analyzed from the /proc -filesystem, so vnStat can be used without root permissions.

$vnstat -tr

Resolving Maven Dependency Conflicts

2007-08-17T01:27:00.000-07:00

Resolving Dependency Conflicts:

Using maven, it is inevitable that two or more artifacts will require different versions of a particular dependency.
To manually resolve conflicts, following steps give very useful information:
(1) build the top level deployment by using:
$mvn -o -X test
this command will list all dependence information.
(2)grep the output of step (1) and remove the [DEBUG] at the beginning of each line
(3)sort the output of step (2), then you can find out easily the version conflicts.

how to automate postgresql maintainence

2007-08-04T08:22:00.000-07:00

Assume that postgresql is installed in /usr/local/pgsql directory.

$crontab -e
22 3 * * * su - postgres -c "/usr/local/pgsql/bin/vacuumdb -a -f" >> /var/log/vacuumdb.log 2>&1
23 3 * * * su - postgres -c "/usr/local/pgsql/bin/pg_dump -Fc -b -f /tmp/db.sql db" > /var/log/dump.log 2>&1

and then save like under vi editor.

$crontab -l
to list the task

How to Change the Timezone in Linux

2007-08-03T09:50:00.001-07:00

1. Logged in as root, check which timezone your machine is currently using by executing `date`. You'll see something like "Mon 17 Jan 2005 12:15:08 PM PST -0.461203 seconds", PST in this case is the current timezone.
2. Change to the directory /usr/share/zoneinfo, here you will find a list of time zone regions. Choose the most appropriate region, if you live in Canada or the US this directory is the "Americas" directory.
3. If you wish, backup the previous timezone configuration by copying it to a different location. Such as `mv /etc/localtime /etc/localtime-old`.
4. Create a symbolic link from the appropiate timezone to /etc/localtime. Example: `ln -s /usr/share/zoneinfo/Europe/Amsterdam /etc/localtime`.
5. If you have the utility rdate, update the current system time by executing `/usr/bin/rdate -s time.nist.gov`.
6. Set the ZONE entry in the file /etc/sysconfig/clock file (e.g. "America/Los_Angeles")
7. Set the hardware clock by executing: `/sbin/hwclock --systohc`

How to resolve permission issues when you move a database between servers that are running SQL Server

2007-08-03T01:37:00.000-07:00

MORE INFORMATION
When you move a database from one server that is running SQL Server to another server that is running SQL Server, a mismatch may occur between the security identification numbers (SIDs) of the logins in the master database and the users in the user database. By default, SQL Server 7.0, SQL Server 2000, and SQL Server 2005 provide the sp_change_users_login system stored procedure to map these mismatched users. However, you can only use the sp_change_users_login stored procedure to map standard SQL Server logins and you must perform these mapping for one user at a time. For more information about the sp_change_users_login stored procedure, see the "sp_change_users_login" topic in SQL Server 7.0,SQL Server 2000, and SQL Server 2005 Books Online.

Solution:

Under a specific database name, remove the user. But if there are schemas defined by the user/owner, you cannot delete the user from the security menu (studio). So, you need to change the owner to dbo first. And then you can delete the owner. then recreate the owner/user again. Finally, change back the schema ownership

how to explicit values to be inserted into the identity column of a table.

2007-07-25T01:31:00.000-07:00

Two conditions are needed:

1) set identity insert to ON:

SET IDENTITY_INSERT db1.dbo.table1 ON

2) specify column list, for example:
INSERT INTO
DB1.dbo.TABLE (column1, column2, column3)
SELECT column1, column2, column3
FROM dbo.TABLE1
dbo.TABLE2 ON dbo.TABLE1.column = dbo.TABLE2.column

optimize postgresql

2007-07-06T00:34:00.001-07:00

Optimizing Postgresql
Ericson Smith
Following Tim Perdue's excellent article on the comparison between MySQL and Postgresql, I decided to take a shot at installing and using this database. For most of our work I use MySQL and will continue to do so, because of its ease of use and unrivaled select query speed, and also because there is no point in trying to mess around with production systems that already work fine.
But some new projects suffered greatly from MySQL's table locking feature when I needed to update data (which I do a lot). Here are my adventures in setting up a Postgresql database server.
Our configuration for a dedicated Postgresql server was:

* Redhat 7.1
* Dual PIII 650Mhz System
* 512MB RAM
* 18Gig SCSI drive for the postgresql data partition

Downloading and Installing
I downloaded and installed the 7.1.2 RPM's from http://postgres.org without any trouble. For a server installation, I only installed: postgresql-server and postgresql-7.1.2 (base).
I then started the server up and running by executing:
/etc/init.d/postgresql start
A small sized database was ported from MySQL (three tables totaling about 5000 records). I created sufficient indexes for postgresql's optimizer to use, and modified our C application to use the postgresql C client interface for a small CGI program that would brutally query this table. This small CGI program receives thousands of queries per minute.
Optimizing
One of the first things I noticed after turning on the CGI program, was that although queries were returned almost as fast as from the previous MySQL based system, the load on the server was much higher -- in fact almost 90-percent! Then I started to go down into the nitty-gritty of things. I had optimized MySQL before by greatly increasing cache and buffer sizes and by throwing more ram towards the problem.
The single biggest thing that you have to do before running Postgresql, is to provide enough shared buffer space. Let me repeat: provide enough buffer space! Let's say you have about 512MB of ram on a dedicated database server, then you need to turn over about 75-percent of it to this shared buffer. Postgresql does best when it can load most or -- even better -- all of a table into its shared memory space. In our case, since our database was fairly small, I decided to allocate 128MB of RAM towards the shared buffer space.
The file /var/lib/pgsql/data/postgresql.conf contains settings for the database server. Postgresql uses system shared memory as a buffer. On a Linux system, you can see how much shared memory was allocated by your system by running the command:
cat /proc/sys/kernel/shmmax
And to view shared memory use on the system:
ipcs
The result will be in bytes. By default RedHat 7.1 allocates 32MB of shared memory, hardly enough for postgresql. I increased this limit to 128MB by doing the command:
echo 128000000 > /proc/sys/kernel/shmmax
Be aware that once you reboot the server, this setting will disappear. You need to place this line in your postgresql startup file, or by editing the /etc/sysctl.conf file for a more permanent setting.
Then in our postgresql.conf I set shared_buffers to 15200. Because Postgresql uses 8K segments, I made a calculation of 128000/8192 plus a 512K overhead. I also set our sort_mem to 32168 (32Megs for a sort memory area). Since connection pooling was in effect, I set max_connections to 64. And fsync was also set to false.

shared_buffers = 15200
sort_mem = 32168
max_connections=64
fsync=false

You can read the manual to tweak other settings, but I never had the need to do so. Note that if you set shared_buffers to more than what your shared memory limit is, postgresql will refuse to start. This confused us for a while, since no logging was taking place. You can tweak the startup file in /etc/init.d for the postmaster to write its output to a log file. Change the fragment from:

/postmaster start > /dev/null 2>

to

/postmaster start > /var/lib/pgsql.log 2>

(or wherever you want to store the log.)
Tailing the log file clearly explained what the problem was.
All sorts of sexy debugging info will show up in this file, which includes SQL syntax errors, the output of EXPLAIN state, emts, connection problems, authentication attempts, and so forth.
I restarted postgresql and brought our CGI online. Our jaws collectively dropped to the floor as postgresql literally flew as soon as it started to use the buffer. Server load by postgresql dropped to just under 10-percent.
One hitch I found with an early version of the system was that it had to build up and tear down a postgresql connection with each request. This was intolerable, so I started to use the connection pooling features of the C library. Server load dropped another few notches with this option. With PHP you will want to use persistent connections (pg_pconnect instead of pg_connect) to fully take advantage of this effect.
Indexes
I cannot emphasize enough the need to have proper indexing in postgresql. One early mistake that I made was to index BIGINT columns. The columns were indexed ok, but postgresql refused to make use them. After two days of tearing out my hair, it came to me that the architecture of the system was 32 bits. Could it be that postgresql refuses to make use of a 64 bit (BIGINT) index? Changing the type to INTEGER quickly solved that problem. Maybe if I had one of those new-fangled 64 bit Itanium processors.
Conclusion
There are many things that you can do with your SQL statements to also improve query response, but these are adequately covered in the interactive postgresql documentation.

optimize postgresql

2007-07-06T00:25:00.001-07:00

optimize postgresql server by three things:

(1)change the max number of file descriptors to 10,000 per process
adding:
* soft nofile 10240
* hard nofile 20000

into /etc/security/limits.conf file
(2)change linux kernel shared memory to 400M.
adding: kernel.shmmax=400000000 into file /etc/sysctl.conf file and reboot the server

(3)change postgresql.conf file to modify the shared buffer space to 300M.

max connection still keep to 100. It should be enough.

sync openvz vps zone with hardware node

2007-06-29T05:44:00.000-07:00

I am using Singapore time.

Login into vps,

and run

#ln -sf /etc/localtime /usr/share/zoneinfo/Asia/Singapore

java outofmemory in linux

2007-06-28T02:46:00.000-07:00

Debian is a stable easy to maintain platform for Java Web Applications. However if you start using some caching frameworks, you may need to do some JVM tuning and here's the information you need to know.

Read this and to the point where you understand that a 32-process on Linux only has 2GB of addressible space. In fact, back in 1999, Linus decreed that 32-bit Linux would never, ever support more than 2GB of memory. "This is not negotiable."

Stacks are memory chunks used for saving variables and passing parameters when calling functions. It's a low level implementation detail, but the important thing to know is that each thread in each process must have it's own stack. Big stacks add up quickly as in the case of tomcat and most web servers where many threads are used to serve requests. Stacks for threads all come out of the same address space, so if you only used memory for stacks of threads you could have 1024 threads with 2MB stacks. In fact in Debian Sarge, there is no way to reduce the amount of memory allocated for the stack of a thread. [1] [2] [3]. Understand that this is not java specific, the same limitation applies to c programs.

Now that we have some fundamental stuff down, it's easy from here. Say you have 2G of Memory and want to use as much memory as possible for your cash for performance considerations. The objects in the cash will be stored in the heap memory. I think you should calculate how much memory you should use with the following formula.

HeapMemory = ProcessAdressSpace - ThreadMemory - PermGen - JVM

If you're running 32-bit, you can only see 2G max.

ProcessAdressSpace = 2G

If you web app is like mine, you'll need 100 threads. Have some librarys that may create threads, tack on another 100 to be safe. 200 threads X 2Mb/Thread = 400M

ThreadMemory = 400M

PermGen is where your defined classes go. Since you use alot of frameworks and have lots of classes, you should set this to 128M

PermGen = 128M

JVM is relatively small, but you need to give it room so that it can work quickly.

JVM = 256M

With those parameters, HeapMemory should not exceed 1264M! Anything more and you're going to slow down your application more than the cache is speeding it up, or you'll introduce nasty a OutOfMemoryException that will drive you crazy. Here's the parameters you want to use.

java -Xmx1264M -XX:MaxPermSize=128m ...

If you upgrade to etch, and set the stack size to 1MB (not recommending without extensive testing), then you can reclaim another 200MB for the heap.

safe_asterisk

2007-06-23T03:03:00.001-07:00

#!/bin/bash

ulimit -c unlimited

run_asterisk()
{
while :; do
cd /tmp
/usr/sbin/asterisk -c >& /dev/null < /dev/null
echo "Automatically restarting Asterisk."
sleep 4
done
}

run_asterisk &

Tuning file descriptor limits on Linux

2007-06-18T18:30:00.000-07:00

Tuning file descriptor limits on Linux

Linux limits the number of file descriptors that any one process may open; the default limits are 1024 per process. These limits can prevent optimum performance of both benchmarking clients (such as httperf and apachebench) and of the web servers themselves (Apache is not affected, since it uses a process per connection, but single process web servers such as Zeus use a file descriptor per connection, and so can easily fall foul of the default limit).

The open file limit is one of the limits that can be tuned with the ulimit command. The command ulimit -aS displays the current limit, and ulimit -aH displays the hard limit (above which the limit cannot be increased without tuning kernel parameters in /proc).

The following is an example of the output of ulimit -aH. You can see that the current shell (and its children) is restricted to 1024 open file descriptors.

core file size (blocks) unlimited
data seg size (kbytes) unlimited
file size (blocks) unlimited
max locked memory (kbytes) unlimited
max memory size (kbytes) unlimited
open files 1024
pipe size (512 bytes) 8
stack size (kbytes) unlimited
cpu time (seconds) unlimited
max user processes 4094
virtual memory (kbytes) unlimited

Increasing the file descriptor limit

The file descriptor limit can be increased using the following procedure:

1. Edit /etc/security/limits.conf and add the lines:

* soft nofile 1024
* hard nofile 65535

2. Edit /etc/pam.d/login, adding the line:

session required /lib/security/pam_limits.so

3. The system file descriptor limit is set in /proc/sys/fs/file-max. The following command will increase the limit to 65535:

echo 65535 > /proc/sys/fs/file-max

4. You should then be able to increase the file descriptor limits using:

ulimit -n unlimited

The above command will set the limits to the hard limit specified in /etc/security/limits.conf.

or---
Increase the limit from 64 (default) to 2048 by issuing the command:

ulimit -n 2048

Also, some applications like the SCO JDK require that the virtual memory resource limit be set to unlimited.

ulimit -v unlimited

Note that you may need to log out and back in again before the changes take effect.

Tuning PostgreSQL for performance

2007-06-07T00:46:00.001-07:00

Tuning PostgreSQL for performance

Shridhar Daithankar, Josh Berkus

July 3, 2003 Copyright 2003 Shridhar Daithankar and Josh Berkus.
Authorized for re-distribution only under the PostgreSQL license (see www.postgresql.org/license).

Table of Contents

1 Introduction
2 Some basic parameters
2.1 Shared buffers
2.2 Sort memory
2.3 Effective Cache Size
2.4 Fsync and the WAL files
3 Some less known parameters
3.1 random_ page_cost
3.2 Vacuum_ mem
3.3 max_fsm_pages
3.4 max fsm_ relations
3.5 wal_buffers
4 Other tips
4.1 Check your file system
4.2 Try the Auto Vacuum daemon
4.3 Try FreeBSD
5 The CONF Setting Guide

1 Introduction
This is a quick start guide for tuning PostgreSQL's settings for performance. This assumes minimal familiarity with PostgreSQL administration. In particular, one should know,

* How to start and stop the postmaster service
* How to tune OS parameters
* How to test the changes

It also assumes that you have gone through the PostgreSQL administration manual before starting, and to have set up your PostgreSQL server with at least the default configuration.

There are two important things for any performance optimization:

* Decide what level of performance you want

If you don't know your expected level of performance, you will end up chasing a carrot always couple of meters ahead of you. The performance tuning measures give diminishing returns after a certain threshold. If you don't set this threshold beforehand, you will end up spending lot of time for minuscule gains.

* Know your load

This document focuses entirely tuning postgresql.conf best for your existing setup. This is not the end of performance tuning. After using this document to extract the maximum reasonable performance from your hardware, you should start optimizing your application for efficient data access, which is beyond the scope of this article.

Please also note that the tuning advices described here are hints. You should not implement them all blindly. Tune one parameter at a time and test its impact and decide whether or not you need more tuning. Testing and benchmarking is an integral part of database tuning.

Tuning the software settings explored in this article is only about one-third of database performance tuning, but it's a good start since you can experiment with some basic setting changes in an afternoon, whereas some other aspects of tuning can be very time-consuming. The other two-thirds of database application tuning are:

* Hardware Selection and Setup

Databases are very bound to your system's I/O (disk) access and memory usage. As such, selection and configuration of disks, RAID arrays, RAM, operating system, and competition for these resources will have a profound effect on how fast your database is. We hope to have a later article covering this topic.

* Efficient Application Design

Your application also needs to be designed to access data efficiently, though careful query writing, planned and tested indexing, good connection management, and avoiding performance pitfalls particular to your version of PostgreSQL. Expect another guide someday helping with this, but really it takes several large books and years of experience to get it right ... or just a lot of time on the mailing lists.

2 Some basic parameters
2.1 Shared buffers
Shared buffers defines a block of memory that PostgreSQL will use to hold requests that are awaiting attention from the kernel buffer and CPU. The default value is quite low for any real world workload and need to be beefed up. However, unlike databases like Oracle, more is not always better. There is a threshold above which increasing this value can hurt performance.

This is the area of memory PostgreSQL actually uses to perform work. It should be sufficient enough to handle load on database server. Otherwise PostgreSQL will start pushing data to file and it will hurt the performance overall. Hence this is the most important setting one needs to tune up.

This value should be set based on the dataset size which the database server is supposed to handle at peak loads and on your available RAM (keep in mind that RAM used by other applications on the server is not available). We recommend following rule of thumb for this parameter:

* Start at 4MB (512) for a workstation
* Medium size data set and 256-512MB available RAM: 16-32MB (2048-4096)
* Large dataset and lots of available RAM (1-4GB): 64-256MB (8192-32768)

PLEASE NOTE. PostgreSQL counts a lot on the OS to cache data files and hence does not bother with duplicating its file caching effort. The shared buffers parameter assumes that OS is going to cache a lot of files and hence it is generally very low compared with system RAM. Even for a dataset in excess of 20GB, a setting of 128MB may be too much, if you have only 1GB RAM and an aggressive-at-caching OS like Linux.

There is one way to decide what is best for you. Set a high value of this parameter and run the database for typical usage. Watch usage of shared memory using ipcs or similar tools. A recommended figure would be between 1.2 to 2 times peak shared memory usage.

2.2 Sort memory
This parameter sets maximum limit on memory that a database connection can use to perform sorts. If your queries have order-by or group-by clauses that require sorting large data set, increasing this parameter would help. But beware: this parameter is per sort, per connection. Think twice before setting this parameter too high on any database with many users. A recommended approach is to set this parameter per connection as and when required; that is, low for most simple queries and higher for large, complex queries and data dumps.

2.3 Effective Cache Size
This parameter allows PostgreSQL to make best possible use of RAM available on your server. It tells PostgreSQL the size of OS data cache. So that PostgreSQL can draw different execution plan based on that data.

Say there is 1.5GB RAM in your machine, shared buffers are set to 32MB and effective cache size is set to 800MB. So if a query needs 700MB of data set, PostgreSQL would estimate that all the data required should be available in memory and would opt for more aggressive plan in terms of optimization, involving heavier index usage and merge joins. But if effective cache is set to only 200MB, the query planner is liable to opt for the more I/O efficient sequential scan.

While setting this parameter size, leave room for other applications running on the server machine. The objective is to set this value at the highest amount of RAM which will be available to PostgreSQL all the time.

2.4 Fsync and the WAL files
This parameters sets whether or not write data to disk as soon as it is committed, which is done through Write Ahead Logging (WAL). If you trust your hardware, your power company, and your battery power supply enough, you set this to No for an immediate boost to data write speed. But be very aware that any unexpected database shutdown will force you to restore the database from your last backup.

If that's not an option for you, you can still have the protection of WAL and better performance. Simply move your WAL files, using either a mount or a symlink to the pg_xlog directory, to a separate disk or array from your main database files. In high-write-activity databases, WAL should have its own disk or array to ensure continuous high-speed access. Very large RAID arrays and SAN/NAS devices frequently handle this for you through their internal management systems.
3 Some less known parameters
3.1 random_page_cost
This parameter sets the cost to fetch a random tuple from the database, which influences the planner's choice of index vs. table scan. This is set to a high value as the default default based on the expectation of slow disk access. If you have reasonably fast disks like SCSI or RAID, you can lower the cost to 2. You need to experiment to find out what works best for your setup by running a variety of queries and comparing execution times.
3.2 Vacuum_mem
This parameter sets the memory allocated to Vacuum. Normally, vacuum is a disk intensive process, but raising this parameter will speed it up by allowing PostgreSQL to copy larger blocks into memory. Just don't set it so high it takes significant memory away from normal database operation. Things between 16-32MB should be good enough for most setups.
3.3 max_fsm_pages
PostgreSQL records free space in each of its data pages. This information is useful for vacuum to find out how many and which pages to look for when it frees up the space.

If you have a database that does lots of updates and deletes, that is going to generate dead tuples, due to PostgreSQL's MVCC system. The space occupied by dead tuples can be freed with vacuum, unless there is more wasted space than is covered by the Free Space Map, in which case the much less convenient "vacuum full" is required. By expanding the FSM to cover all of those dead tuples, you might never again need to run vacuum full except on holidays.

The best way to set max _ fsm _ pages is interactive; First, figure out the vacuum (regular) frequency of your database based on write activity; next, run the database under normal production load, and run "vacuum verbose analyze" instead of vacuum, saving the output to a file; finally, calculate the maximum total number of pages reclaimed between vacuums based on the output, and use that.

Remember, this is a database cluster wide setting. So bump it up enough to cover all databases in your database cluster. Also, each FSM page uses 6 bytes of RAM for administrative overhead, so increasing FSM substantially on systems low on RAM may be counter-productive.
3.4 max _ fsm _ relations
This setting dictates how many number of relations (tables) will be tracked in free space map. Again this is a database cluster-wide setting, so set it accordingly. In version 7.3.3 and later, this parameter should be set correctly as a default. In older versions, bump it up to 300-1000.
3.5 wal_buffers
This setting decides the number of buffers WAL(Write ahead Log) can have. If your database has many write transactions, setting this value bit higher than default could result better usage of disk space. Experiment and decide. A good start would be around 32-64 corresponding to 256-512K memory.
4 Other tips
4.1 Check your file system
On OS like Linux, which offers multiple file systems, one should be careful about choosing the right one from a performance point of view. There is no agreement between PostgreSQL users about which one is best.

Contrary to popular belief, today's journaling file systems are not necessarily slower compared to non-journaling ones. Ext2 can be faster on some setups but the recovery issues generally make its use prohibitive. Different people have reported widely different experiences with the speed of Ext3, ReiserFS, and XFS; quite possibly this kind of benchmark depends on a combination of file system, disk/array configuration, OS version, and database table size and distribution. As such, you may be better off sticking with the file system best supported by your distribution, such as ReiserFS for SuSE Linux or Ext3 for Red Hat Linux, not to forget XFS known for it's large file support . Of course, if you have time to run comprehensive benchmarks, we would be interested in seeing the results!

As an easy performance boost with no downside, make sure the file system on which your database is kept is mounted "noatime", which turns off the access time bookkeeping.
4.2 Try the Auto Vacuum daemon
There is a little known module in PostgreSQL contrib directory called as pgavd. It works in conjunction with statistics collector. It periodically connects to a database and checks if it has done enough operations since the last check. If yes, it will vacuum the database.

Essentially it will vacuum the database when it needs it. It would get rid of playing with cron settings for vacuum frequency. It should result in better database performance by eliminating overdue vacuum issues.
4.3 Try FreeBSD
Large updates, deletes, and vacuum in PostgreSQL are very disk intensive processes. In particular, since vacuum gobbles up IO bandwidth, the rest of the database activities could be affected adversely when vacuuming very large tables.

OS's from the BSD family, such as FreeBSD, dynamically alter the IO priority of a process. So if you lower the priority of a vacuum process, it should not chew as much bandwidth and will better allow the database to perform normally. Of course this means that vacuum could take longer, which would be problematic for a "vacuum full."

If you are not done with your choice of OS for your server platform, consider BSD for this reason.

5 The CONF Setting Guide
Available here is an Annotated Guide to the PostgreSQL configuration file settings, in both OpenOffice.org and PDF format. This guide expands on the official documentation and may eventually be incorporated into it.

* The first column of the chart is the GUC setting in the postgresql.conf file.
* The second is the maximum range of the variable; note that the maximum range is often much larger than the practical range. For example, random_page_cost will accept any number between 0 and several billion, but all practical numbers are between 1 and 5.
* The third column contains an enumeration of RAM or disk space used by each unit of the parameter.
* The fourth column indicates whether or not the variable may be SET from the PSQL terminal during an interactive setting. Most settings marked as "no" may only be changed by restarting PostgreSQL.
* The fifth column quotes the official documentation available from the PostgreSQL web site.
* The last column is our notes on the setting, how to set it, resources it uses, etc. You'll notice some blank spaces, and should be warned as well that there is still strong disagreement on the value of many settings.

Users of PostgreSQL 7.3 and earlier will notice that the order of the parameters in this guide do not match the order of the parameters in your postgresql.conf file. This is because this document was generated as part of an effort to re-organize the conf parameters and documentation; starting with 7.4, this document, the official documentation, and the postgresql.conf file are all in the same logical order.

As noted in the worksheet, it covers PostgreSQL versions 7.3 and 7.4. If you are using an earlier version, you will not have access to all of these settings, and defaults and effects of some settings will be different.

iax2 one-way audio

2007-06-05T08:25:00.000-07:00

After a while of operation, IAX becomes behaving incorrectly, no audio or 1-way, and no-answer :

This problem happened on asterisk 2.1.14.

The solution is configure the
jitterbuffer=no

GWT-app does not first show when loading (IE 6)

2007-05-31T02:03:00.000-07:00

Modules can contain references to external JavaScript and CSS files, causing them to be automatically loaded when the module itself is loaded.

But when injection of CSS file make the IE does not show the GWT widgits until you click on the page manually.

To work around this, donot use css injection but using normal way of embed the css file in html template

jboss ejb3 and eager loading

2007-05-28T08:45:00.000-07:00

In case of using annotation @OneToMany(mappedBy="order",cascade=CascadeType.ALL, fetch=FetchType.EAGER), the ear deployment broken.

To work around this problem, remove the fetch=FetchType.EAGER

or

Use either: Set or List with an explicit @IndexColumn, rather than a bag semantic collection like Collection.

@IndexColumn is an hibernate annotation

Solaris x86

2007-05-18T08:11:00.000-07:00

Hardware:

To setup the server testing enviroment, Sun utral 20 box is used. This box has two harddisks: (1)/dev/dsk/c1d0 and (2)/dev/dsk/c2d0

During installation of the Solaris 10, the first harddisk is used to install the boot, swap and root partitions. Basically, which likes the normal linux setting up.

The second harddisk /dev/dsk/c2d0 is left for the "zpool", although zpool can also use the extra space in the first disk.

After OS installation, the system status is : Solaris OS is installed in the first hardisk (/dev/dsk/c1d0). And the second harddisk is totally not used.

--------------------------After the installation of OS-------------------------
(1)create resource pool by command zpool
#zpool create spool c2d0
(2)now the pool named "spool" is created. Which can be listed by:
#zpool list
(3)Creating a ZFS File System by allocating space from the pool "spool"
#zfs create spool/z1fs
(4)now, new ZFS file system is created, which can be listed by:
#zfs list
(5)Now, it is time to create the parent directory of all zones: In the following, /zones directory is created.
#mkdir /zones
(6)To create zone "z1", i create directory /zones/z1,
#mkdir /zones/z1
(7)and mount the newly create ZFS spool/z1fs to /zone/z1
#zfs set mountpoint=/zones/z1 spool/z1fs
(8)and set the quato for ZFS spool/z1fs
#zfs set quota=10G spool/z1fs
(9) It is time to create zone z1 now:
#zonecfg -z z1
z1: No such zone configured
Use 'create' to begin configuring a new zone
zonecfg:myzone< create
zonecfg:myzone< set zonepath=/zones/z1
zonecfg:myzone< verify
zonecfg:myzone< commit
zonecfg:myzone< exit
(10)Install the zone by using the zoneadm
#chmod 700 /zones/z1
#zoneadm -z z1 install
(11)Boot the zone to complete the installation, using the zoneadm command.
# zoneadm -z z1 boot
(12)Use the zlogin command to connect to the zone console and answer the initialization questions:
#zlogin -C z1
(13)to shutdown zone
#zlogin z1 init 5

----------------------------------------------------

Configure network for the zone

Context: the Sun utral 20 box has only one physical network interface. To make the zone created network accessable, one logical interface will be assigned to each zone.

(1)list the physical network interface on Sun utral 20 box:
#ifconfig -a
The result shows that the physical network interface is nge0
(2)create logical interface and assign it to zone z1 and then up the logical interface:
#ifconfig nge0:1 plumb 192.168.1.89 netmask 255.255.255.0 zone z1 up
(3)login into z1:
#zlogin z1
(4)modify /etc/ssh/sshd_config , so that "root" can be used to do remote login
(5)restart sshd:
#svcadm restart ssh

------------------------------------------------------------------

DNS clients configuration:

After zone is running, it could encount such a problem: When you do ping to other computer, the naming resolving does not work. This is due to the DNS client configuration is not correct.

All DNS clients require the presence of the /etc/nsswitch.conf and /etc/resolv.conf files. Note that the DNS server must also be configured as a DNS client if it intends to use its own DNS services.

The /etc/nsswitch.conf file specifies the resolver library routines to be used for resolving host names and addresses. Modify the /etc/nsswitch.conf file by editing the hosts entry and adding the dns keyword. To ensure proper network interface configuration during the boot process, make sure that the files keyword is listed first. The following example shows a hosts entry configured for DNS:

hosts: files dns

The /etc/resolv.conf file specifies the name servers that the client must use, the client's domain name, and the search path to use for queries.

; resolv.conf file for DNS clients of the one.edu domain
domain office1.abc.net
nameserver 192.168.1.119
search office1.abc.net

Observe that the search keyword specifies domain names to append to queries that were not specified in the FQDN format. The first domain listed following the search keyword designates the client's domain. If both "domain" and "search" keywords are present, then the last one in the file is used and the other one(s) are ignored.

The nameserver keyword specifies the IP address of the DNS servers to query. Do not specify host names. You can use up to three nameserver keywords to increase your chances of finding a responsive server. In general, list the name servers that are nearer to the local network first. The client attempts to use the loopback address if there is no nameserver keyword or if the /etc/resolv.conf file does not exists.

------------------------------------------------------------------------

Configure DHCP client

After crashing of sun ultra 20 box, a dell box with onboard networking card is used to install solaris.

Problem 1: solaris doesn't support this on-board networking card.
Solution: a standalone PCI network card is used.

Problem 2: Solaris cannot detect this PCI card, and what is the interface name of this card?
Solution: Google suggest to try names like le0, iprb0, elxl0 and rtls0 etc.

Problem3: how to configure the DHCP client?
Solution: for a network interface, to configure it DHCP, create two empty files under /etc directory:
(a)hostname.INTERFACENAME , (b)dhcp.INTERFACENAME

After trying google suggested interface names, it is found that elxl0 is correct for this card.

--------------------------------------------------------------------------

Configure static IP addresses for the solaris box:

Network Interface Cards are what allow your system to talk to the network. When they don't work, neither do you. I will cover how to configure, troubleshoot, and modify your interfaces. I will not be covering routing issues, that will follow in the next article. My goal here is to get your interface up and properly running.

The first place to start is installing and testing the hardware. Once you have installed the hardware, SPARC systems can be tested at the EPROM level to verify the network interface cards. Use the manual that accompanies the interface card on how to test that specific card. Solaris x86 is a little different, as there is no true EPROM, and the drivers are different. However, Solaris x86 2.6 is Plug and Play compatible, and I have had fairly good luck adding network interface cards.

Once you have confirmed at the hardware and driver level that everything works, the fun can begin. The place to start is the ifconfig command. This powerful command allows you configure and modify your interfaces in real time. However, any modifications made with ifconfig are not permanent. When the system reboots, it will default to its previous configuration. I will first show you how to make all modifications with the ifconfig command. The second half of this article will cover making these modifications permanent by modifying the proper configuration files.
ifconfig

ifconfig -a

will show you which interfaces are currently installed and active. Remember, just because you added the physical network interface card does NOT mean it is active. If you do an ifconfig before you have configured the device, the interface will not show up. Once configured however, the typical output of the ifconfig -a command would look like this:

lo0: flags=849 mtu 8232
inet 127.0.0.1 netmask ff000000
elxl0: flags=863 mtu 1500
inet 192.168.1.132 netmask ffffff00 broadcast 192.168.1.255
ether 8:0:20:9c:6b:2d

Here we see two interfaces, lo0 and elxl0. lo0 is the standard loopback interface found on all systems. elxl0 is a 10/100 Mbps interface. All hme interfaces are 10/100 Mbps, all le interfaces are 10 Mbps, all qe interface are quad 10 Mbps, and qfe interfaces are quad 10/100 Mbps. There are three lines of information about the interface. The first line is about the TCP/IP stack. For the interface elxl0, we see the system is up, running both broadcast and multicast, with a mtu (maximum transfer unit) of 1500 bytes, standard for an Ethernet LAN. Notrailers is a flag no longer used, but kept for backwards compatibility reasons.

The second line is about the IP addressing. Here we see the IP address, netmask in hexadecimal format, and the broadcast address. The third line is the MAC address. Unlike most interfaces, Sun Microsystems's interfaces derive the MAC addressing from the NVRAM, not the interface itself. Thus, all the interfaces on a single SPARC system will have the same MAC address. This does not cause a problem in routing, since most NICs are always on a different network. Note, you must be root to see the MAC address with the ifconfig command, any other user will only see the first two lines of information.

The first step in bringing up an interface is "plumbing" the interface. By plumbing, we are implementing the TCP/IP stack. We will use the above interface, elxl0, as an example. Lets say we had just physically added this network interface card and rebooted, now what? First, we plumb the device with the plumb command.

ifconfig elxl0 plumb

This sets up the streams needed for TCP/IP to use the device. However, the stack has not been configured as you can see below.

elxl0: flags=842 mtu 1500
inet 0.0.0.0 netmask 0
ether 8:0:20:9c:6b:2d

The next step is to configure the TCP/IP stack. We configure the stack by adding the IP address, netmask, and then telling the device it is up. All this can be down in one command, as seen below.

ifconfig elxl0 192.168.1.132 netmask 255.255.255.0 up

This single command configures the entire device. Notice the up command, which initializes the interface. The interface can be in one of two states, up or down. When an interface is down, the system does not attempt to transmit messages through that interface. A down interface will still show with the ifconfig command, however it will not have the word "up" on the first line.
Virtual interfaces

Before moving on to the configuration files, I would first like to cover virtual interfaces. A virtual interface is one or more logical interfaces assigned to an already existing interface. Solaris can have up to 255 virtual interfaces assigned to a single interface.

Once again, lets take the interface elxl0 as an example. We have already covered how to configure this device. However, lets say the device is on a VLAN (virtual LAN) with several networks sharing the same wire. We can configure the device elxl0 to answer to another IP address, say 172.20.15.4. To do so, the command would be the same as used for elxl0, except the virtual interface is called elxl0:*, where * is the number you assign to the virtual interface. For example, virtual interface one would be elxl0:1. The command to configure it looks as follows.

ifconfig elxl0:1 172.20.15.4 netmask 255.255.0.0 up

Once you have configured the virtual interface, you can compare elxl0 and elxl0:1 with the ifconfig command.

elxl0: flags=843 mtu 1500
inet 192.168.1.132 netmask ffffff00 broadcast 192.168.1.255
ether 8:0:20:9c:6b:2d
elxl0:1: flags=842 mtu 1500
inet 172.20.15.4 netmask ffff0000 broadcast 172.20.255.255

Here you see the two devices, both of which are on the same physical device. Notice how the virtual interface elxl0:1 has no MAC address, as this is the same device as elxl0. We can repeat this process all the way up to elxl0:255. The operating system and most applications will treat these virtual devices as totally independent devices.

Note, Matthew A. Domurat has identified a "bug" with Solaris 2.6. When working with virtual interfaces, Solaris 2.6 will randomly select one of the interfaces as its source address for every packet sent. These are the patches to fix this:

* 105786-05: SunOS 5.6: /kernel/drv/ip patch
* 105787-04: SunOS 5.6_x86: /kernel/drv/ip patch

Configuration files

Now you know how to configure your network interface cards. Unfortunately, any modifications, additions, or deletions you make with ifconfig are only temporary, you will lose these configurations when you reboot. I will now discuss what files you have to configure to make these changes permanent.

The place to start is the file /etc/hostname.*, where * is the name of the interface. In the case of elxl0, the file name is /etc/hostname.elxl0. The virtual interface elxl0:1 would have the file name /etc/hostname.elxl0:1. This file has a single entry, the name of the interface. This name is used in the /etc/hosts file to resolve name to IP address.

The file /etc/hostname.* is critical, this is what causes the device to be plumbed. During the boot process, the /etc/rcS.d/S30network.sh file reads all the /etc/hostname.* files and plumbs the devices. Once plumbed, the devices are configured by reading the /etc/hosts and the /etc/netmasks file. By reading these two files, the device is configured for the proper IP and netmask, and brought to an up state. Lets take the device elxl0 as an example. During the boot process, /etc/rcS.d/S30network.sh looks for any /etc/hostname.* files. It finds /etc/hostname.elxl0, which contains the following entry.

homer

/etc/rcS.d/S30network.sh looks in /etc/hosts and resolves the name homer with an IP address of 192.168.1.132. The device elxl0 is now assigned this IP address. The script then looks at /etc/netmasks to find the netmask for that IP address. With this information, the startup script brings up interface elxl0 with an IP address of 192.168.1.132 and a netmask of 255.255.255.0. It may seem redundant having the script review the netmask of a class C address. However, do not forget that, starting with 2.6, Solaris supports both classless routing and VLSM (Variable Length Subnet Masks), both of which I will discuss in my next article.

As you have seen in this example, there are three files that must be modified for every interface. The first is /etc/hostname.*, this is the file you create to designate the interface's name. The second file is /etc/hosts, here you resolve the IP to the interface name. Last is /etc/netmasks, this is where you define the netmask of the IP address.

--------------------------------------------------------------
Install Solaris OS and partition on Dell Box

The Dell Box has one IDE harddisk with about 120G capacity. Solaris identifies this disk to be c0d0.

During installation, fdisk partition it as
c0d0s0 which mount on /
c0d0s1 ----swap
c0d0s7 ----/export/home
c0d0s3,4,5,6 all not used but with 20G space. they will be used as the resources of the resource pool created by zpool.

----------------------------------------------------

create harddisk resource pool

(1)#zpool create spool c0d0s3
(2)#zpool add spool c0d0s4
(4)#zpool list
NAME SIZE USED AVAIL CAP HEALTH ALTROOT
spool 39G 196K 39.0G 0% ONLINE

-----------------------------------------------------------

set static IP for global zone:

refer to the doc on above comments....

To set static IP for global zone:

(1)create /etc/hosts file. so that:
#less hosts
#
# Internet host table
#
192.168.1.23 benchmark1
(2)create /etc/hostname.elxl0 so that:
#less hostname.elxl0
benchmark1

After these two files created, global zone are network enabled.

-----------------------------------------------------------------
setup static ip for zone benchmark2 (non-global zone)

After login into global zone,

if doing #ifconfig -a,
lo0: flags=2001000849 mtu 8232 index 1
inet 127.0.0.1 netmask ff000000
elxl0: flags=1000843 mtu 1500 index 2
inet 192.168.1.23 netmask ffffff00 broadcast 192.168.1.255
ether 0:1:2:12:67:53

#zonecfg -z benchmark2

=>add net
==>set ip=192.168.1.23
==>set physical=elxl0
...
and commit

After boot zone benchmark2, Now, do #ifconfig -a again:
lo0: flags=2001000849 mtu 8232 index 1
inet 127.0.0.1 netmask ff000000
lo0:1: flags=2001000849 mtu 8232 index 1
zone benchmark2
inet 127.0.0.1 netmask ff000000
elxl0: flags=1000843 mtu 1500 index 2
inet 192.168.1.23 netmask ffffff00 broadcast 192.168.1.255
ether 0:1:2:12:67:53
elxl0:1: flags=1000843 mtu 1500 index 2
zone benchmark2
inet 192.168.1.22 netmask ffffff00 broadcast 192.168.1.255

It indicates that non-global zone is already network enabled.

-----------------------------------------------

JBOSS setup

Copy jboss from zpeter4:

Including:
(1)/opt/jboss-4.0.4.GA
(2)/var/jboss
(3)/opt/bin/myip (this is used in jboss's run.sh file)
(4)if java security manager is included in the java parameter, make sure the corresponding policy file also there

---------------------------------------------------

JBOSS user

(1)user jboss must be created
(2)group jboss must be created
(3)home directory of user jboss must be /var/jboss

[ Show » ]
Peter Yang [16/May/07 12:27 PM] JBOSS user (1)user jboss must be created (2)group jboss must be created (3)home directory of user jboss must be /var/jboss

----------------------------------------------------------

Setup SMF for jboss:

(1)export smf script from zpeter4
#svccfg export jboss >/tmp/jboss.xml

and copy this exported file to new zone benchmark2.

(2)Copy /opt/lib/svc/method/svc-jboss from zpeter4 to benchmark2 zone in the corresponding directory

(3)import manifect file jboss.xml in benchmark2 zone.
/usr/sbin/svccfg -v import /tmp/jboss.xml

(4)enable jboss
#svcadm enable jboss

(5)monitoring the status of jboss service
#svcs -xv jboss

------------------------------------------------

how to remove service or edit manifest file

svcadm -v disable svc:/network/jboss
svccfg -v delete svc:/network/jboss
svccfg -v import /var/svc/manifest/jboss.xml

----------------------------------------------------

How to run NFS file server and mount NFS client

Problem:

For the development enviroment, there are four JBOSS servers. To enable the web log feature of the portal, it is required for all these JBOSS server to send their log files to a central NFS server, on which jbossportal server is running.

Parameters:
(1)JBOSS servers:
zpeter2, zpeter3, zpeter4 and benchmark2 (dell computer)

(2)NFS file server is running on storm, on which zroland3 zone is running. JBossPortal is running with zroland3 zone.

Steps:
(1)edit /etc/dfs/dfstab on storm to include following lines:
share -F nfs -o rw -d "zpeter2:/var/jboss/log" /zones/zroland3/root/nfsd/zpeter2
share -F nfs -o rw -d "zpeter3:/var/jboss/log" /zones/zroland3/root/nfsd/zpeter3
share -F nfs -o rw -d "zpeter4:/var/jboss/log" /zones/zroland3/root/nfsd/zpeter4
share -F nfs -o rw -d "benchmark2:/var/jboss/log" /zones/zroland3/root/nfsd/benchmark2
(2)make sure the mode of /zones/zroland3/root/nfsd/zpeter2, /zones/zroland3/root/nfsd/zpeter3, /zones/zroland3/root/nfsd/zpeter3 and /zones/zroland3/root/nfs/benchmark2 are 777. So that files can be written in these directories.

(3)restart NFS server

(4)on zone zpeter2, edit /etc/vfstab to include line:
storm:/zones/zroland3/root/nfsd/zpeter2 - /log nfs - yes rw
and do the same thing for zones zpeter3, zpeter4 and benchmark2

(5)restart these zones

Java VM Tuning - GC selection

2007-05-18T08:10:00.000-07:00

GC collector selection:

(1)default collector(serial collector).
(2)throughput collector,which try to maximum CPU usage (minimize the CPU
usage by GC). But it could introduce big pause. So, this collector
cannot be used for RTS game server.
(3)Concurrent Low Pause Collector. On uniprocessor, this collector will
have worse performance than the default GC collector (serial collector).
On Two CPU machine, this collector will not pause the running
application, but it consume too much percentage of CPU. But for more CPU
(like 3 or 4), this collector is better than the default collector.

Currently, it is assumed that 2 processors machine will be used.
So, the default GC will be used.

The two main factors for JVM optimization are :

(1)Heap Size (-Xms and -Xmx)
(2)The second most influential knob is the proportion of the heap
dedicated to the young generation. By default, the young generation size
is controlled by NewRatio. For example, setting -XX:NewRatio=3 means
that the ratio between the young and tenured generation is 1:3. In other
words, the combined size of the eden and survivor spaces will be one
fourth of the total heap size. The bigger this ratio, the less pause.
However, more frequently the GC runs. This can be logged by another
command line options: -verbose:gc -XX:+PrintGCDetails.

If this ratio set to 15, you will see the GC runs very with less pause
each time.

Have no idea about the default value of this ratio.

Total Heap Size:

Since collections occur when generations fill up, throughput is
inversely proportional to the amount of memory available. Total
available memory is the most important factor affecting garbage
collection performance.

Unless having problems with pauses, try granting as much memory as
possible to the virtual machine. The default size (64MB) is often too
small.

To make sure the pause is not too big, adjust the NewRatio accordingly.

T1/E1 jumper on TE11xP, TE2xxP, and TE4xxP

2007-04-13T20:03:00.001-07:00

These cards have a physical jumper for selecting whether the ports are T1 (open) or E1 (closed).
But there is also a software override for the jumper in the wct4xxp and wct11xp drivers. (See http://kb.digium.com/entry/1/121/)

To set all spans to E1 mode, use:

insmod wct4xxp t1e1override=0xFF

To set all spans to T1 mode, use:

insmod wct4xxp t1e1override=0x00

An even easier way is to add this to your /etc/modprobe.d/zaptel file:

options wct4xxp t1e1override=0xFF

The argument is a bitmask, which can be used to set each span separately, if that is needed for some reason. Span 1 is 0x01, span 2 is 0x02, span 3 is 0x04, and span 4 is 0x08. For example, "t1e1override=0x0B" would set spans 1, 2, and 4 to E1 mode, and leave span 3 in T1 mode.

custom log4j appender for jboss

2007-04-13T08:18:00.000-07:00

it is very interesting to customize a log4j append, through which the jboss can send log to google talk IM.

To deploying the gtalklogger(written by myself) and its dependent jar files, you cannot put them simplily into jboss../server/default/lib directory.

Instead, you need to create a directory to Set the boot patch directory, which Must be absolute or url.

./run.sh -d absolute-path-to-the-boot-batch-directory

refer to the output of:
$./run.sh --help

TE412P and centos 4.4

2007-04-12T08:10:00.000-07:00

i am struggling with the TE412P and cent os 4.4.

(1)libpri-1.2.2
(2)zaptel-1.2.3
(3)zaptel-1.2.3

These packages are a bit old because i am trying to duplicate an old system.

when i run /sbin/ztcfg, i always got the following error:
-----------------------
Notice: Configuration file is /etc/zaptel.conf
line 0: Unable to open master device '/dev/zap/ctl'

1 error(s) detected
-----------------------

I know it is related to udev of linux kernel 2.6.* . And also i read README.udev in zaptel-1.2.3 directory.

Unless i run following modprobe manually, the /dev/zap/.... files get created. But these files should be created automatically when rebooting (udev system's function)

$modprobe zaptel
$modprobe wct4xxp

Only after above manually loaded module, the os will create the /dev/zap/xxxx .

.... BAD experience.....

asterisk <---IAX2---> asterisk

2007-04-07T20:39:00.000-07:00

i have two asterisk Boxes:

mobile users<--ISDN/PRI->BOX A<--IAX2-->BOX B.

(1)CALLERID(dnid) issue
When mobile users dial DDI number assigned to BOX A, the CALLERID(dnid) is available. But when Box A forward the call to BOX B, the CALLERID(dnid) is empty within Box B dialplan.

To work around this problem, i make an agreement between Box A and Box B. When Box A dial Box B, it specifies the IAX2/peer/extensionnumber, where extension number is the CALLER(dnid) of BOX A. And in dialplan of Box B, add Set(CALLERID(dnid)=${EXTEN}) to reset the CALLERID(dnid).

(2)CALLERID(num) issue:
To send the caller ID to box B, sendani=yes, need to be configured in the box A peer configuration

(3)Native transfer
To control the media path, notransfer=yes, need to be configured in the Box B.

IP traffic monitoring

2007-04-05T21:05:00.000-07:00

I want to monitor the network usage between two servers. After researching, i recommended following two tools:

(1)ntop
(2)iptraf

Java and OpenVZ VPS

2007-04-01T05:44:00.000-07:00

After installation of openvz VPS by following its user guide, i cannot even run $java -version within the VPS.

After discovering, i found that the default VPS configuration cannot be used to run java application.

(1)Example, VPS 101 is running the vps.basic configuration profile. I run the following command: $vzcalc 101 and the result show that my hardware can support about 80 VPS. But if these VPSes are used to run java application, it is obviously not correct.

(2)So, i need to create/calcualte the profile myself. Fortunately, OpenVZ has command :
$vzsplit -n 10 -f vps.java
This means that i want to create 10 VPSes for java application in the hardware node.

(3)Finally, i apply this new configuration profile to VPS 101.
$vzctl set 101 --applyconfig vps.java --save

(4)Login into VPS 101 again. It is very happy to run java.

update OpenVZ VPS

2007-03-31T02:22:00.000-07:00

After searching, i found that there are no information about how to update a open VZ VPS. It is worth to write it down for other people's reference.

Why do i need to update VPS? Because i need to compile code in VPS. With the prepackaged VPS template, it does not include glibc-devel, gcc etc development tools.

I have CentOS 4.4 CDs in hand. So, following is what i did.

My first VPS ID is 101.

At the very begining, i tried: root$vzyum 101 update. It just failed. I think it could be due to the slow internet connection or the yum repository is not available....

So, i man yum and find that it could be update or install local packages. So i did the following: (cd current directory to the CD mounted directory)

$vzyum 101 update glibc-common-2.3.4-2.25.i386.rpm
$vzyum 101 install gcc

It works.

cd ripper

2007-03-30T07:47:00.000-07:00

Cdparanoia is a Compact Disc Digital Audio (CDDA) extraction tool, commonly known on the net as a 'ripper'. The application is built on top of the Paranoia library, which is doing the real work (the Paranoia source is included in the cdparanoia source distribution). Like the original cdda2wav, cdparanoia package reads audio from the CDROM directly as data, with no analog step between, and writes the data to a file or pipe in WAV, AIFC or raw 16 bit linear PCM.

It only works on Linux.

connect openoffice to postgresql database

2007-03-28T23:24:00.000-07:00

OpenOffice is useful to view remote database server.

First, create a database role to only view the remote database:
(1)#create role peter login;
(2)#alter role peter with password '12345';
(3)#grant select on table tablename to peter;
(4)modify pg_hba.conf file so that it includes line: (this line must be positioned so that it is the first to match for the connection request).
host dbname peter2 192.168.1.0/24 password
(5)reload the configuration
(6)test with psql -U peter -h hostip -W dbname

Second, OpenOffice configuration:
(1)Make sure Java (http://java.sun.com) is installed in the computer
(2)Download & Install OpenOffice 2.x.
(3)Download jdbc driver for PostgreSQL. (http://jdbc.postgresql.org)
(4)Run OpenOffice. Navigate to: Tools-->Options-->Java. Select Java and set the CLASSPATH so that the CLASSPATH include the downloaded JDBC driver file. And ok.
(5)Navigate: File-->New-->Database. Select :Connecting to an existing database by JDBC. And use jdbc:postgresql://databasehostip:5432/databasename as databaseURL and org.postgresql.Driver as JDBC driver class. And then type your database username and select "Password required".

That is all.