socket « WordPress.com Tag Feed

HttpRequest in Oracle SQL über Java Function

rhde — Thu, 26 Nov 2009 15:35:31 +0000

Mittel Java kann Oracle nahezu beliebig aufgebohrt werden.

Zunächst eine Klasse zum Laden von Webseiten per URL:

create or replace and compile java source named java_http
as
import java.net.*;
import java.io.*;
public class java_http {
  public static String get(String url) throws Exception {
    URL u = new URL(url);
    URLConnection c = u.openConnection();
    c.setDoOutput(true);
    if (c instanceof HttpURLConnection) {
       ((HttpURLConnection)c).setRequestMethod("GET");
    }
    OutputStreamWriter out = new OutputStreamWriter(
      c.getOutputStream()
    );
    out.close();
    BufferedReader in = new BufferedReader(
      new InputStreamReader(
        c.getInputStream()
      )
    );
    String result = "";
    String s = null;
    while ((s = in.readLine()) != null) {
      result += s;
    }
    in.close();
    return result;
  }
}

Für diese Klasse eine Stored Function in Oracle definieren:

create or replace function javahttpget(p_string in varchar2)
return varchar2
as language java name 'java_http.get(java.lang.String) return java.lang.String';

Testaufruf:

select javahttpget('http://www.oracle.com/') from dual;

Fehler wegen Berechtigung:

ORA-29532: Java-Aufruf durch nicht abgefangene Java-Exception beendet:
java.security.AccessControlException: the Permission (java.net.SocketPermission
www.oracle.com resolve) has not been granted to SCOTT. The PL/SQL to grant this
is dbms_java.grant_permission( 'SCOTT', 'SYS:java.net.SocketPermission','www.oracle.com', 'resolve' )

Berechtigung vergeben:

conn scott as sysdba
exec dbms_java.grant_permission('SCOTT','SYS:java.net.SocketPermission','www.oracle.com','resolve')
exit
select javahttpget('http://www.oracle.com/') from dual;

ss: Display Linux TCP / UDP Network and Socket Information

Jo B — Thu, 26 Nov 2009 14:30:18 +0000

The ss command is used to dump socket statistics. It allows showing information similar to netstat c

Proxy List Checker & Updater

guidj0s — Thu, 19 Nov 2009 15:58:40 +0000

Heya. This is another perl project, and it might be handy. If you use the internet a lot, you may eventually build and save huge proxy lists. The problem is, and this is especially true if your list consists of free proxy servers, the number of servers going on and offline all the time is really high, so sometimes it can be annoying to find a good working one. This is what this tool’s for. It’ll read a proxy list containing IP:PORT pairs and try a connection on each of them, for a specified number of seconds. If the timeout is reached, the proxy is considered temporarily dead and isn’t logged. If it connects, the program prints out the pair and logs it to the updated list. The list contains the date and time of execution within its file name. The bigger the proxy list the better, for obvious reasons, but you shouldn’t delete the original one after running a check. Proxy servers may spring back to life after a little while, so it can’t hurt to just leave them all there in the original list.

The Code

Modify this to your liking, it’s simple and straightforward. It’ll spawn 1000 (woot!) threads per “round”, which will each try to connect to a server socket (the proxy server). Change this if you like. Here it is:

#!/usr/bin/perl

use IO::Socket;
use Threads;

#-----------------------------------+
# guidjos' Proxy List Checker v1.1  |
#-----------------------------------+

if (@ARGV < 1){

 print "\n\n\n   Failed. Usage: $0 [proxylisttxtfile] [timeout(seconds)].  \n\n";
 print "         If no timeout is specified, default == 4 will be used.\n\n\n guidj0s\n";
 exit;
}

@hora = localtime;
$nomelista = "proxylist_$hora[3]-$hora[4]--$hora[2]h$hora[1]m.log";
open(novalista, ">>$nomelista");     # I know, I know.

if ($ARGV[1]){
 $tout = $ARGV[1];
}
else{
 $tout = 4;
}

sub testaservidor{

 my($ip, $falha) = @_;

 my $sockteste = IO::Socket::INET->new(
  PeerAddr => $ip,
  Proto => 'tcp',
  Timeout => $falha,
  Reuse => 1
 );

 if ($sockteste){
  $sockteste->close();
  print "    $ip responded.\n\n";
  print novalista "$ip";
  return 1;
 }
 else{
  print "  $ip is dead.\n\n";
  return 0;
 }
}

open(dados, $ARGV[0]) || die("\n\n    proxy list file specified was invalid\n\n\n");
@proxies = <dados>;
close dados;

my $atual = 1;
my $vivos;

print "\n\n Starting to check proxy servers...\n\n\n ";

while ($atual <= $#proxies){
 for my $quantas (1..1000){
  if ($atual <= $#proxies){
   my $crianca = threads->new(\&testaservidor, $proxies[$atual-1], $tout);
   $atual++;
  }
 }
 foreach (threads->list){
  $resultado = $_->join;
  if ($resultado){
   $vivos++;
  }
 } 
}

close novalista;
print "\n\n Done.\n\n $vivos out of $#proxies servers responded and were\n  logged to $nomelista\n\n\n";

3D Power Socket Powers 5-Devices Simultaneously

swiff88 — Wed, 18 Nov 2009 19:11:17 +0000

Art Lebedev reveals the 3D Power Socket, featuring a unique design that pops open to reveal 5 electrical outlets at the push of a button. Pricing and availability have not yet been announced. Click here for first picture in gallery.

[via Toxel]

Multithreaded Perl Portscanner

guidj0s — Sun, 15 Nov 2009 00:33:06 +0000

While learning sockets in Perl (to put it more acurately, while learning the IO::Socket module), I came across a few implementations of Perl portscanners which, even though functional, were far from practical. I know, I know, you can just get Nmap if you’re looking for a good portscanner, but hey, you can build your own scanner and make it decent.

The implementations I often found (there were also some php versions) were too slow because they worked by looping through the port numbers and trying them sequentially. All I did was create some threads to speed things up, and the resulting speed is actually acceptable. The following code loops through the port range specified, creating rounds of 30 threads to test the ports by calling the “testarporta()” sub routine on the current iteration’s port.

On to the code:

#!/usr/bin/perl
use IO::Socket;
use Threads;

#+---------------------------------------------------------+
#|                                                         |
#|               Fanatic Port Scanner v 1.0                |
#|                  c0d3d by guidj0s                       |
#|                                                         |
#+--:: About ::--------------------------------------------+
#|							   |
#|     Spawns 30 threads per round (more than enough).     |
#|  							   |
#|							   |
#|	usage:						   |
#|							   |
#|	fanatic.pl [ip] [startport] [endport]		   |
#|                                                         |
#+---------------------------------------------------------+

sub testarporta{
  my $tentar = new IO::Socket::INET (
  	PeerAddr => $_[0],
  	PeerPort => $_[1],
  	Proto => 'tcp',
	Timeout => '1'
  );

  if ($tentar) {
  	print "$_[1] ";
  	$portaberta = $_[1];
  	open(logar, '>>fanatic_scanresults.txt');
  	print logar "$portaberta ";
  	close logar;
	close($tentar);
  }

}

if (@ARGV < 3){

	die "\n\n\n    Failed. Usage: $0 [ip] [startport] [endport]\n\n\n";

}

my ($ip, $pi, $pf) = @ARGV;

print "\n\n -------------------------------:: Fanatic Port Scanner by guidj0s ::-------\n\n";
print " Working...\n\n\n  Open Ports: ";

open(scanlog, '>>fanatic_scanresults.log');
print scanlog "\n\n\n-----------:: Last Scan Results for $ip ::--------------\n\n";
print scanlog "\nPort Range Selected: $pi-$pf";
print scanlog "\n\n\nOpen Ports: ";
close scanlog;

while ($pi <= $pf){
	for my $controle (1..30){
		my $agente = threads->new(\&testarporta, $ip, $pi);
		$pi++;
	}
	foreach (threads->list){
		$_->join;
	}
}

	print "\n\n\t\t\tScan finished.\n\n";

As you can see, the ports found open are logged to fanatic_scanresults.log. If you looked at the code you realized a port is considered “open” only when a connection can be established on it.

The Win32 GUI version

I did make one. I coded it using the Win32::GUI module. I know TK would have been a better option (as I found out quite soon), but that’s what I went with and I really don’t think it’s worth the hassle to migrate (I’m not working on it again any time soon).

As you may know, Win32::GUI isn’t thread safe. In this case, whenever I tried to access a Win32::GUI object from within a child thread, the program crashed. I solved the problem by creating a shared variable ($aberta), which is updated everytime an open port is found. I also created a control variable ($ultima), which is used to check whether the last value printed out/logged was already printed or if the value currently stored in $aberta has already been handled (so I only need to print it when $aberta != $ultima. After doing so, I update $ultima with the current value stored in $aberta), and then access the Win32::GUI element from the main thread.

I added a functionality to the program, which is the option of providing a portlist plain-text file to scan for specific ports only. Enough talking, here’s the code: http://guidjos.justfree.com/fntcgui.txt

Now that I look at my code again, I see there’s a silly mistake. You should never access files like I did here:

open(scanlog, ">>$logto");

But I’ll leave this for another post, as this one’s long enough. The handling of user-input related mistakes isn’t really thorough either, so feel free to improve the code (sharing the new version would be cool, I might give you some space to talk about it and share your code here on the blog ).

come as you are

Sarah — Fri, 13 Nov 2009 04:35:51 +0000

am- The window reflects blue skies and the warmth of the sun, all the while little annoyances bounce

Histeria

Borges — Thu, 12 Nov 2009 01:58:09 +0000

Quarta-feira, 11 de Novembro de 2009, 23h20

Mais um papo filosófico com o Wendel. Como esse cara consegue pensar em tantas coisas, numa diversidade como essa? O aprender é a verdade absoluta do mundo. Tudo gira em torno disso. Ter alguém que te ensine, e você aprende o que for útil pra você. Claro, ensinar também, o que você acha ser importante. “Cada um tem sua própria sede“.

Agora me lembrei do Felipe aqui em casa vestido com uma camisa do São Paulo. Tudo de uma aposta que ele fez com a Thais. Me pergunto se ele mudará de time só porque ela é são-paulina.. nesse momento, Palmeiras acaba de empatar o jogo, o que deixa o tricolor em segundo lugar na classificação do campeonato que ele vencerá.

Ficamos a aula de português inteira resumindo o texto que leremos aos cegos. Enrolamos o máximo possível, é claro; lemos algumas notícias sobre o apagão de ontem, e todo aquele caos (ou conspiração governamental) na usina de Itaipu. Na de matemática, pra variar só mais um pouquinho, fizemos exercícios, e o Dimas, sempre com tesão de dar aula, animado com isso (acabo de perceber que escrevo muito na ~~terceira pessoa~~ primeira pessoa do plural, e não há necessidade, uma vez que isto é um diário ). Entreguei aquele clipe horrível na aula de artes e vi uma apresentação sobre histeria do Andrey. Não gostei do assunto, já vi outros melhores sobre psicologia.

Almoço, Barão. Coca gelada. Depois, expo do último grupo da informática B. O programa delas não funcionou, mas acho que os professores pegarão menos pesado. Afinal, era um software bem difícil, e só o grupo do Igor fez o socket a mão, não pegando nada pronto da Internet. Mas eu sei que elas tentaram, porque as vi muitas vezes fazendo o dito cujo. Nessa semana e pelas próximas duas, devo ter aula normal. Aulas e provas, infelizmente. Ainda tenho que ler um livro e fazer um site para o dia dezoito. Mas em Dezembro, deve ser só farra.

Não encontrei um espaço, mas tinha que colocar esse evento aqui: hoje, no carro, Felipe, melzinho. Ihh, pegou mal. Calma. Felipe estava comendo aquele mel que vem em pacotinhos. Uma dica para uma boa degustação: enfia tudo na boca e vá mastigando. É satisfação garantida!

23h55

Testing portaudio and speex - part 4

slworkthings — Wed, 11 Nov 2009 00:35:57 +0000

Continue.

AudioEngine header file:
#ifndef _AUDIOENGINE_H_
#define _AUDIOENGINE_H_

#include “mysocket.h”
#include “portaudio.h”
#include “san_speex.h”
#include <qwidget.h>

#define SAMPLE_RATE 16000
#define FRAMES_PER_BUFFER 320
#define PA_SAMPLE_TYPE paInt16
typedef short SAMPLE;
#define SAMPLE_SILENCE (0)
#define NUM_CHANNELS    1
class AudioEngine;
typedef struct
{
    SanSpeexEnc     speexenc;
    SAMPLE          recordbuffer[FRAMES_PER_BUFFER * NUM_CHANNELS];
    char            encodedBufPlus8[FRAMES_PER_BUFFER * NUM_CHANNELS * 2 ];
    SanSpeexDec     speexdec;
    SAMPLE          playbackbuffer[FRAMES_PER_BUFFER * NUM_CHANNELS];
    AudioEngine    *obj;
} paTestData;
//============================================
class AudioEngine : public QWidget
{
    Q_OBJECT
public:
    AudioEngine();
    virtual ~AudioEngine();

    void recvPlaybackDataIn(const QByteArray& ba);
    void setSelfLoop(bool flag);
    bool isSelfLoop() const { return m_isSelfLoop; }
protected:
    virtual void closeEvent(QCloseEvent *);

private slots:
void slotReceivedData(const QByteArray&);
void slotReceivedHandshake(const QString& hisId);

private:
    static int s_recordCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData);
    static int s_playCallback(const void *inputBuffer, void *outputBuffer,
                              unsigned long framesPerBuffer,
                              const PaStreamCallbackTimeInfo* timeInfo,
                              PaStreamCallbackFlags statusFlags,
                              void *userData);
    static int s_loopCallback(const void *inputBuffer, void *outputBuffer,
                              unsigned long framesPerBuffer,
                              const PaStreamCallbackTimeInfo* timeInfo,
                              PaStreamCallbackFlags statusFlags,
                              void *userData);

    bool initPa();
    bool unInitPa();
    bool startPaRecorder(int id);
    bool startPaPlayback(int id);
    bool stopPaRecorder();
    bool stopPaPlayback();
    bool startPaRecorderPlaybackLoop(int inputId, int outputId);
    bool stopPaRecorderPlaybackLoop();

void sendRecordDataOut(char *buf, int len);

private:
    MyServerSocket    *m_serverSocket;
    QString            m_recorderId;
    QString            m_playbackId;

    PaStream          *m_streamIn, *m_streamOut;
    PaError            m_errIn, m_errOut;
    int                m_inputId, m_outputId;

paTestData m_data;
bool m_isSelfLoop;
};

#endif // _AUDIOENGINE_H_

AudioEngine source file:

#include “audioengine.h”
#include <qapplication.h>
#include <windows.h>
//#include <mmddk.h>

//===================================
AudioEngine::AudioEngine()
            :QWidget(),
             m_serverSocket(0),
             m_recorderId(QString::null),
             m_playbackId(QString::null),
             m_streamIn(0),
             m_streamOut(0),
             m_errIn(paNoError),
             m_errOut(paNoError),
             m_inputId(-1),
             m_outputId(-1),
             m_isSelfLoop(true)
{
    qDebug(“AE ctor”);
    m_serverSocket = new MyServerSocket();
    connect(m_serverSocket, SIGNAL(fireReceivedData(const QByteArray&)),
                            SLOT(slotReceivedData(const QByteArray&)));
    connect(m_serverSocket, SIGNAL(fireReceivedHandshake(const QString&)),
                            SLOT(slotReceivedHandshake(const QString&)));
    qDebug(“m_serverSocket port = %d”, m_serverSocket->port());

    resize(100, 100);
    move(0, 0);
    hide();

    m_data.obj = this;
    m_data.speexdec.setSanSpeexEnc(&m_data.speexenc);
    initPa();
}

AudioEngine::~AudioEngine()
{
    qDebug(“AE dtor”);
    delete m_serverSocket;
    m_serverSocket = 0;
    unInitPa();
}

void AudioEngine::closeEvent(QCloseEvent *)
{
qDebug(“AE::closeEvent”);
qApp->exit(0);
}

void AudioEngine::slotReceivedData(const QByteArray& ba)
{
    qDebug(“AE::slotRecvData = %d”, ba.size());
    const char *data = ba.data();
    if (ba.size() >= 4 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’)
    {
        char cmd = data[3];
        switch (cmd)
        {
        case ‘1′: //return device list;   dev1\ndev2\n…
            {
                QString devList(ba);
                devList = devList.mid(4);
                qDebug(“1. DevList = ” + devList);
            }
            break;
        case ‘2′: //set recorder device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“2. RecorderDevice = ” + devName);
                m_inputId = devName.toInt();
            }
            break;
        case ‘3′: //set playback device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“3. PlaybackDevice = ” + devName);
                m_outputId = devName.toInt();
            }
            break;
        case ‘4′: //start recorder
            qDebug(“4. Start Recording”);
            if (!m_isSelfLoop)
            {
                if (m_inputId != -1 && m_streamIn == 0)
                    startPaRecorder(m_inputId);
            }
            else
            {
                if (m_inputId != -1 && m_outputId != -1 && m_streamIn == 0)
                    startPaRecorderPlaybackLoop(m_inputId, m_outputId);
            }
            break;
        case ‘5′: //start playback
            qDebug(“5. Start Playback”);
            if (!m_isSelfLoop)
            {
                if (m_outputId != -1 && m_streamOut == 0)
                    startPaPlayback(m_outputId);
            }
            else
            {
                if (m_inputId != -1 && m_outputId != -1 && m_streamIn == 0)
                    startPaRecorderPlaybackLoop(m_inputId, m_outputId);
            }
            break;
        case ‘6′: //stop recorder
            qDebug(“6. Stop Recording”);
            if (!m_isSelfLoop)
                stopPaRecorder();
            else
                stopPaRecorderPlaybackLoop();
            break;
        case ‘7′: //stop playback
            qDebug(“7. Stop Playback”);
            if (!m_isSelfLoop)
                stopPaPlayback();
            else
                stopPaRecorderPlaybackLoop();
            break;
        case ‘Q’: //totally exit
            qDebug(“Q. Quit”);
            if (m_serverSocket)
                m_serverSocket->stop();
            show();
            break;
        default:
            break;
        }//switch()
    }//”cmd”
    else //binary
    {
    }//binary
}//slotReceivedData()

void AudioEngine::slotReceivedHandshake(const QString& hisId)
{
    qDebug(“AE::slotRecvHandshake = ” + hisId);
    if (hisId == “recorder”)
        m_recorderId = hisId;
    else if (hisId == “playback”)
        m_playbackId = hisId;
}//slotReceivedHandshake()

int AudioEngine::s_recordCallback(const void *inputBuffer, void *outputBuffer,
                                  unsigned long framesPerBuffer,
                                  const PaStreamCallbackTimeInfo* timeInfo,
                                  PaStreamCallbackFlags statusFlags,
                                  void *userData)
{
    paTestData *data = (paTestData*)userData;
    const SAMPLE *rptr = (const SAMPLE*)inputBuffer;
    SAMPLE *wptr = data->recordbuffer;
    long framesToCalc;
    framesToCalc = framesPerBuffer;
    long i;
    int finished = paContinue;
    bool isSelfLoop = data->obj->isSelfLoop();

    (void) outputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

    if( inputBuffer == NULL )
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = SAMPLE_SILENCE;
            if (NUM_CHANNELS == 2)
                *wptr++ = SAMPLE_SILENCE;
        }
    }
    else
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = *rptr++;
            if (NUM_CHANNELS == 2)
                *wptr++ = *rptr++;
        }
    }

    int encSizePlus8 = data->speexenc.encode(data->recordbuffer, data->encodedBufPlus8);
    if (encSizePlus8 > 0)
    {
        int encSizePlus4 = ((int *)data->encodedBufPlus8)[0];

        //if (!isSelfLoop)
        {
            //send out encodedBufPlus8 to spydonk
            data->obj->sendRecordDataOut(data->encodedBufPlus8, encSizePlus8);
        }

        /*
        if (isSelfLoop)
        {
            //when seedonk receiving some audio buf from server, call following line
            data->speexdec.put(data->encodedBufPlus8+4, encSizePlus4);
        }
        */
    }

return finished;
}//s_recordCallback()

int AudioEngine::s_playCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData)
{
    paTestData *data = (paTestData*)userData;
    SAMPLE *rptr = data->playbackbuffer;
    SAMPLE *wptr = (SAMPLE*)outputBuffer;
    int finished = paContinue;
    unsigned int framesLeft = 0;
    int i;
    bool isSelfLoop = data->obj->isSelfLoop();

data->speexdec.get(rptr);
framesLeft = framesPerBuffer;

    (void) inputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

    for( i=0; i<framesPerBuffer; i++ )
    {
        *wptr++ = *rptr++;
        if (NUM_CHANNELS == 2)
            *wptr++ = *rptr++;
    }

rptr = data->playbackbuffer;
data->speexdec.afterPlayback(rptr, true);

return finished;
}//s_playCallback()

int AudioEngine::s_loopCallback(const void *inputBuffer, void *outputBuffer,
                                unsigned long framesPerBuffer,
                                const PaStreamCallbackTimeInfo* timeInfo,
                                PaStreamCallbackFlags statusFlags,
                                void *userData)
{
    paTestData *data = (paTestData*)userData;
    const SAMPLE *rptr = (const SAMPLE*)inputBuffer;
    SAMPLE *wptr = (SAMPLE*)outputBuffer;
    SAMPLE *prevPlayPtr = data->playbackbuffer;
    long framesToCalc;
    framesToCalc = framesPerBuffer;
    long i;
    int finished = paContinue;

    (void) outputBuffer; /* Prevent unused variable warnings. */
    (void) timeInfo;
    (void) statusFlags;
    (void) userData;

//data->speexenc.playbackEcho(prevPlayPtr, true);

    if( inputBuffer == NULL )
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = SAMPLE_SILENCE;
            //*prevPlayPtr++ = SAMPLE_SILENCE;
            if (NUM_CHANNELS == 2)
            {
                *wptr++ = SAMPLE_SILENCE;
                //*prevPlayPtr++ = SAMPLE_SILENCE;
            }
        }
        return 0;
    }
    else
    {
        for( i=0; i<framesToCalc; i++ )
        {
            *wptr++ = *rptr;
            //*prevPlayPtr++ = *rptr;
            rptr++;
            if (NUM_CHANNELS == 2)
            {
                *wptr++ = *rptr;
                //*prevPlayPtr++ = *rptr;
                rptr++;
            }
        }
    }

    //data->speexenc.captureEcho(wptr);
    data->speexenc.captureEcho(wptr, prevPlayPtr);
    for (i=0; i<framesToCalc; i++)
    {
        *prevPlayPtr++ = *wptr++;
    }

    return finished;
}//s_loopCallback()
bool AudioEngine::initPa()
{
    PaError err = Pa_Initialize();
    if (err == paNoError)
    {
        int numDevices = Pa_GetDeviceCount();
        int inputId, outputId;
        int prevHostApi = -1;
        for(int id=0; id<numDevices; id++)            /* Iterate through all devices. */
        {
            const PaDeviceInfo *pdi = Pa_GetDeviceInfo(id);
            if (prevHostApi != pdi->hostApi)
            {
                const PaHostApiInfo *info = Pa_GetHostApiInfo(pdi->hostApi);
                qDebug(“=== HostApi, %d, type=%d, name=%s ====”, pdi->hostApi, info->type, info->name);
                qDebug(“=== def I=%d, defO=%d ====”, info->defaultInputDevice, info->defaultOutputDevice);

prevHostApi = pdi->hostApi;

            }
            qDebug(“[%d]=[%s], IChs=%d, OChs=%d”,
                               id, pdi->name,
                               pdi->maxInputChannels,
                               pdi->maxOutputChannels);

//#define DRV_RESERVED 0×0800
//#define DRV_QUERYDEVICEINTERFACE (DRV_RESERVED + 12)
//#define DRV_QUERYDEVICEINTERFACESIZE (DRV_RESERVED + 13)

            /*
            if (pdi->maxInputChannels > 0)
            {
                DWORD pathSize = 0;
                if (waveInMessage((HWAVEIN)id, 0×0800+13,
                                   (DWORD_PTR)&pathSize, 0) != MMSYSERR_NOERROR)
                {
                    qDebug(“**** pathSize = %d”, pathSize);
                    char *path = new char[pathSize];
                    memset(path, 0, pathSize);
                    if (waveInMessage((HWAVEIN)id, 0×0800+12,
                                       (DWORD_PTR)path, sizeof(path)) != MMSYSERR_NOERROR)
                    {
                        qDebug(“**** path = %s”, path);
                    }
                    delete [] path;
                }
                else
                    qDebug(“**** ERROR %d”, id);
            }
            */
        }
    }
    qDebug(“======================================”);
    return (err == paNoError);
}

bool AudioEngine::unInitPa()
{
    if (m_streamIn)
        Pa_CloseStream(m_streamIn);
    m_streamIn = 0;
    if (m_streamOut)
        Pa_CloseStream(m_streamOut);
    m_streamOut = 0;

Pa_Terminate();
return true;
}

bool AudioEngine::startPaRecorder(int inputId)
{
PaStreamParameters inputParameters;

    /* Record some audio. ——————————————– */
    m_errIn = Pa_OpenStream(&m_streamIn,
                            &inputParameters,
                            NULL,                  /* &outputParameters, */
                            SAMPLE_RATE,
                            FRAMES_PER_BUFFER*NUM_CHANNELS,
                            paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                            AudioEngine::s_recordCallback,
                            &m_data);
    if(m_errIn != paNoError)
        return false;

    m_errIn = Pa_StartStream(m_streamIn);
    if(m_errIn != paNoError)
        return false;
    qDebug(“Now recording!!”);
    return true;
}//startPaRecorder()

bool AudioEngine::startPaPlayback(int outputId)
{
PaStreamParameters outputParameters;

    outputParameters.device = outputId;
    outputParameters.channelCount = NUM_CHANNELS;
    outputParameters.sampleFormat = PA_SAMPLE_TYPE;
    outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputId)->defaultLowOutputLatency;
    outputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Output Device = [%s], latency = %f”, Pa_GetDeviceInfo(outputId)->name, outputParameters.suggestedLatency);

    qDebug(“Begin playback.”);
    m_errOut = Pa_OpenStream(&m_streamOut,
                             NULL, /* no input */
                             &outputParameters,
                             SAMPLE_RATE,
                             FRAMES_PER_BUFFER*NUM_CHANNELS,
                             paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                             AudioEngine::s_playCallback,
                             &m_data);
    if(m_errOut != paNoError)
        return false;

    m_errOut = Pa_StartStream(m_streamOut);
    if(m_errOut != paNoError )
        return false;
    return true;
}//startPaPlayback()

bool AudioEngine::startPaRecorderPlaybackLoop(int inputId, int outputId)
{
if (m_streamIn != 0) //already started
return true;

PaStreamParameters inputParameters;
PaStreamParameters outputParameters;

    inputParameters.device = inputId;
    inputParameters.channelCount = NUM_CHANNELS;
    inputParameters.sampleFormat = PA_SAMPLE_TYPE;
    inputParameters.suggestedLatency = Pa_GetDeviceInfo(inputId)->defaultLowInputLatency;
    inputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Input Device = [%s], latency = %f”, Pa_GetDeviceInfo(inputId)->name, inputParameters.suggestedLatency);
    outputParameters.device = outputId;
    outputParameters.channelCount = NUM_CHANNELS;
    outputParameters.sampleFormat = PA_SAMPLE_TYPE;
    outputParameters.suggestedLatency = Pa_GetDeviceInfo(outputId)->defaultLowOutputLatency;
    outputParameters.hostApiSpecificStreamInfo = NULL;
    qDebug(“Output Device = [%s], latency = %f”, Pa_GetDeviceInfo(outputId)->name, outputParameters.suggestedLatency);

    /* RecordPlayback Loop some audio. ——————————————– */
    m_errIn = Pa_OpenStream(&m_streamIn,
                            &inputParameters,
                            &outputParameters,
                            SAMPLE_RATE,
                            FRAMES_PER_BUFFER*NUM_CHANNELS,
                            paClipOff|paDitherOff,      /* we won’t output out of range samples so don’t bother clipping them */
                            AudioEngine::s_loopCallback,
                            &m_data);
    if(m_errIn != paNoError)
        return false;

    m_errIn = Pa_StartStream(m_streamIn);
    if(m_errIn != paNoError)
        return false;
    qDebug(“Now looping!!”);
    return true;
}//startPaRecorderPlaybackLoop()

bool AudioEngine::stopPaRecorder()
{
    if (m_streamIn)
        Pa_CloseStream(m_streamIn);
    m_streamIn = 0;
    return true;
}//stopPaRecorder()

bool AudioEngine::stopPaPlayback()
{
    if (m_streamOut)
        Pa_CloseStream(m_streamOut);
    m_streamOut = 0;
    return true;
}//stopPaPlayback()

bool AudioEngine::stopPaRecorderPlaybackLoop()
{
return stopPaRecorder();
}//stopPaRecorderPlaybackLoop()

void AudioEngine::sendRecordDataOut(char *buf, int len)
{
if (m_isSelfLoop)
return;

    if (!m_recorderId.isNull() && m_serverSocket)
    {
        QByteArray ba;
        ba.setRawData(buf, len);
        m_serverSocket->send(ba, m_recorderId);
        ba.resetRawData(buf, len);
    }
}//sendRecordDataOut()

void AudioEngine::recvPlaybackDataIn(const QByteArray& ba)
{
if (m_isSelfLoop)
return;

    //buffer:
    // encodedBufSize + 4 | timestamp | encodedBuf
    // ——————–+———–+——————–
    // 4                  | 4        | encodedBufSize – 4
    int len = 0;
    if (!m_playbackId.isNull() && (len = ba.size()) >
    {
        char *buf = new char [len];
        memcpy(buf, ba.data(), len);
        m_data.speexdec.put(buf+4, len-4); //encodedBufWithTimeStamp
        delete [] buf;
        buf = 0;
    }
}//recvPlaybackDataIn()

void AudioEngine::setSelfLoop(bool flag)
{
    m_isSelfLoop = flag;
    if (m_isSelfLoop)
    {
        m_recorderId = “recorder”;
        m_playbackId = “playback”;
    }
}

Testing portaudio and speex - part 3

slworkthings — Wed, 11 Nov 2009 00:34:31 +0000

Continue.

speex header file:

#ifndef _SAN_SPEEX_H_
#define _SAN_SPEEX_H_
//copy from speex_jitter_buffer.h(.c)
#include <speex/speex_jitter.h>
#include <speex/speex.h>
#include <speex/speex.h>
#include <speex/speex_jitter.h>
#include <speex/speex_preprocess.h>
#include <speex/speex_echo.h>
#ifdef __cplusplus
extern “C” {
#endif

/** @defgroup SpeexJitter SpeexJitter: Adaptive jitter buffer specifically for Speex
* This is the jitter buffer that reorders UDP/RTP packets and adjusts the buffer size
* to maintain good quality and low latency. This is a simplified version that works only
* with Speex, but is much easier to use.
* @{
*/

/** Speex jitter-buffer state. Never use it directly! */
typedef struct SpeexJitter {
   SpeexBits current_packet;         /**< Current Speex packet */
   int valid_bits;                   /**< True if Speex bits are valid */
   JitterBuffer *packets;            /**< Generic jitter buffer state */
   void *dec;                        /**< Pointer to Speex decoder */
   spx_int32_t frame_size;           /**< Frame size of Speex decoder */
} SpeexJitter;

/** Initialise jitter buffer
*
* @param jitter State of the Speex jitter buffer
* @param decoder Speex decoder to call
* @param sampling_rate Sampling rate used by the decoder
*/
void speex_jitter_init(SpeexJitter *jitter, void *decoder, int sampling_rate);

/** Destroy jitter buffer */
void speex_jitter_destroy(SpeexJitter *jitter);

/** Put one packet into the jitter buffer */
void speex_jitter_put(SpeexJitter *jitter, char *packet, int len, int timestamp);

/** Get one packet from the jitter buffer */
void speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *start_offset);

/** Get pointer timestamp of jitter buffer */
int speex_jitter_get_pointer_timestamp(SpeexJitter *jitter);

#ifdef __cplusplus
}
#endif
#define SAMPLING_RATE 16000
#define FRAME_SIZE 320
////////////////////////////////////////////////////////////////////

class SanSpeexEnc
{
public:
SanSpeexEnc();
~SanSpeexEnc();

    /**
     * @return 4 + 4 + encodedLen
     * @rawin must be 320 length
     * 4+encodedLen |   timestamp | encodedBuf
     * ————–+————–+————–
     * 4            |   4          | encodedLen
     */
    int encode(const short *rawin, char *encodedBufOutWithTimestampAndLen);

int playbackEcho(const short *rawin, bool ok); //TODO: remember to sync

void captureEcho(short *rawin);
void captureEcho(short *rawin, short *playback);

private:
    SpeexPreprocessState *preprocess;
    void                 *enc_state;
    SpeexBits             enc_bits;
    int                   send_timestamp;
    short                 pcm[FRAME_SIZE], pcm2[FRAME_SIZE];
    SpeexEchoState       *echo_state;
    char                  encodedBuf[FRAME_SIZE*2];

};
class SanSpeexDec
{
public:
SanSpeexDec();
~SanSpeexDec();

    void setSanSpeexEnc(SanSpeexEnc *ptr);
    int put(const char *encodedBufWithTimestamp, int encodedLenWithTimestamp);
    int get(short *rawout);
    int afterPlayback(short *rawin, bool ok);

private:
   void               *dec_state;
   SpeexBits           dec_bits;
   short               pcm[FRAME_SIZE];
   SanSpeexEnc        *speexenc;
   SpeexJitter         jitter;
   int                 mostUpdatedTSatPut;
   bool                firsttimecalling_get;

};

/////////////////////////////////////////////////////////////////////

#endif // _SAN_SPEEX_H_

Speex source file:
#include <stdio.h>
#include <limits.h>
#include “san_speex.h”
#ifndef NULL
#define NULL 0
#endif
#define ENABLE_AEC
#ifdef ENABLE_AEC
#define USE_AEC_CAPTURE /* will print a lot of speex warning */
#endif

#include <qglobal.h>
//#define NEED_DUMP
#include <stdio.h>
FILE *file = 0;
char msg[128];
void debugPrint(const char *msg)
{
#ifdef NEED_DUMP
    if (file == 0)
        file = fopen(“dump.txt”, “a”);
    fprintf(file, msg);
#endif
}

void closeDebugPrint()
{
#ifdef NEED_DUMP
    if (file)
        fclose(file);
    file = 0;
#endif
}

#define ECHOTAILSIZE 25
short psSpeaker[320 * ECHOTAILSIZE * 10];
void speex_jitter_init(SpeexJitter *jitter, void *decoder, int sampling_rate)
{
jitter->dec = decoder;
speex_decoder_ctl(decoder, SPEEX_GET_FRAME_SIZE, &jitter->frame_size);

jitter->packets = jitter_buffer_init(jitter->frame_size);

speex_bits_init(&jitter->current_packet);
jitter->valid_bits = 0;
}

void speex_jitter_destroy(SpeexJitter *jitter)
{
jitter_buffer_destroy(jitter->packets);
speex_bits_destroy(&jitter->current_packet);
}

void speex_jitter_put(SpeexJitter *jitter, char *packet, int len, int timestamp)
{
   JitterBufferPacket p;
   p.data = packet;
   p.len = len;
   p.timestamp = timestamp;
   p.span = jitter->frame_size;
   jitter_buffer_put(jitter->packets, &p);
   sprintf(msg, “put %d\n”, timestamp);
   debugPrint(msg);
}

void speex_jitter_get(SpeexJitter *jitter, spx_int16_t *out, int *current_timestamp)
{
   int i;
   int ret;
   spx_int32_t activity;
   int bufferCount = 0;
   JitterBufferPacket packet;
   //char data[40960];
   //packet.data = data;
   //packet.len = 40960;
   packet.data = reinterpret_cast<char *>(psSpeaker);
   packet.len = 320 * ECHOTAILSIZE * 10;

   if (jitter->valid_bits)
   {
      /* Try decoding last received packet */
      ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
      if (ret == 0)
      {
         jitter_buffer_tick(jitter->packets);
         return;
      } else {
         jitter->valid_bits = 0;
      }
   }

   if (current_timestamp)
    ret = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, current_timestamp);
   else
    ret = jitter_buffer_get(jitter->packets, &packet, jitter->frame_size, NULL);

   if (ret != JITTER_BUFFER_OK)
   {
      /* No packet found */
      speex_decode_int(jitter->dec, NULL, out);
   } else {
      speex_bits_read_from(&jitter->current_packet, packet.data, packet.len);
      /* Decode packet */
      ret = speex_decode_int(jitter->dec, &jitter->current_packet, out);
      if (ret == 0)
      {
         jitter->valid_bits = 1;
      } else {
         /* Error while decoding */
         for (i=0;i<jitter->frame_size;i++)
            out[i]=0;
      }
   }
   speex_decoder_ctl(jitter->dec, SPEEX_GET_ACTIVITY, &activity);
   if (activity < 30)
   {
      jitter_buffer_update_delay(jitter->packets, &packet, NULL);
   }
   jitter_buffer_tick(jitter->packets);
   //ret = jitter_buffer_ctl(jitter->packets, JITTER_BUFFER_GET_AVALIABLE_COUNT, &bufferCount);
   //sprintf(msg, “   get %d bufferCount=%d\n”, speex_jitter_get_pointer_timestamp(jitter), bufferCount);
   //debugPrint(msg);
}

int speex_jitter_get_pointer_timestamp(SpeexJitter *jitter)
{
   return jitter_buffer_get_pointer_timestamp(jitter->packets);
}
//===========================================================
SanSpeexEnc::SanSpeexEnc()
            :preprocess(0),
             enc_state(0),
             enc_bits(),
             send_timestamp(0),
             echo_state(0)
{
    for (int i=0; i<FRAME_SIZE; i++)
        pcm[i] = 0;

int tmp;
float tmpf;

    enc_state = speex_encoder_init(&speex_wb_mode);
    tmp = 3; //3,4,7,8,9,10 are not working
    speex_encoder_ctl(enc_state, SPEEX_SET_QUALITY, &tmp);
    tmp = 7;
    speex_encoder_ctl(enc_state, SPEEX_SET_COMPLEXITY, &tmp);
    speex_bits_init(&enc_bits);

    echo_state = speex_echo_state_init(FRAME_SIZE, ECHOTAILSIZE*FRAME_SIZE);
    tmp = SAMPLING_RATE;
    speex_echo_ctl(echo_state, SPEEX_ECHO_SET_SAMPLING_RATE, &tmp);

preprocess = speex_preprocess_state_init(FRAME_SIZE, SAMPLING_RATE);
speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_ECHO_STATE, echo_state);

    tmp = 1;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DENOISE, &tmp);
    tmp = 0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC, &tmp);
    tmp = 1;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_VAD, &tmp);

    tmp = 0;
speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB, &tmp);
    tmpf = 0.0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB_DECAY, &tmpf);
    tmpf = 0.0;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_DEREVERB_LEVEL, &tmpf);

    tmp = 8000;//30000;
    //speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_TARGET, &tmp);
    tmp = 8000;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_LEVEL, &tmp);
    tmp = 5;
    //speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_AGC_MAX_GAIN, &tmp);
    tmp = -30;
    speex_preprocess_ctl(preprocess, SPEEX_PREPROCESS_SET_NOISE_SUPPRESS, &tmp);
}

SanSpeexEnc::~SanSpeexEnc()
{
    speex_encoder_destroy(enc_state); //–Destroy the encoder state
    speex_echo_state_destroy(echo_state);
    speex_preprocess_state_destroy(preprocess);
    speex_bits_destroy(&enc_bits); //–Destroy the bit-packing struct
    closeDebugPrint();
}

/**
* @return 4 + 4 + encodedLen
* @rawin must be 320 length
* 4+encodedLen |   timestamp | encodedBuf
* ————–+————–+————–
* 4            |   4          | encodedLen
*/
int SanSpeexEnc::encode(const short *rawin, char *encodedBufOutWithTimestampAndLen)
{
#ifdef ENABLE_AEC
    /* Perform echo cancellation */
   #ifdef USE_AEC_CAPTURE
    speex_echo_capture(echo_state, rawin, pcm2);
   #else
    speex_echo_cancellation(echo_state, rawin, psSpeaker, pcm2);
   #endif
    for (int i=0;i<FRAME_SIZE;i++)
        pcm[i] = pcm2[i];
#else
    for (int i=0;i<FRAME_SIZE;i++)
        pcm[i] = rawin[i];
#endif

speex_bits_reset(&enc_bits);

    /* Apply noise/echo suppression */
    bool isSpeech = speex_preprocess_run(preprocess, pcm);
    /* Encode */
    int needTransmit = speex_encode_int(enc_state, pcm, &enc_bits);
    int packetSize = 0;
    if (isSpeech && needTransmit)
    {
        packetSize = speex_bits_write(&enc_bits, encodedBufOutWithTimestampAndLen+8, FRAME_SIZE*2);

        ((int*)encodedBufOutWithTimestampAndLen)[0] = packetSize+4;
        ((int*)encodedBufOutWithTimestampAndLen)[1] = send_timestamp;
        qDebug(“packetSize=%d, timestamp=%d”, packetSize, send_timestamp);
    }

send_timestamp += FRAME_SIZE;

if (send_timestamp >= INT_MAX)
send_timestamp = 0;

    if (packetSize > 0)
        return packetSize+4+4;
    else
        return 0;
}

int SanSpeexEnc::playbackEcho(const short *rawin, bool ok)
{
#ifdef ENABLE_AEC
    //TODO : sync
    /* Put frame into playback buffer */
   #ifdef USE_AEC_CAPTURE
    if (!ok)
        speex_echo_state_reset(echo_state);
    speex_echo_playback(echo_state, rawin);
   #endif
#endif
    return 1;
}

void SanSpeexEnc::captureEcho(short *rawin)
{
#ifdef ENABLE_AEC
   #ifdef USE_AEC_CAPTURE
    speex_echo_capture(echo_state, rawin, pcm2);
    for (int i=0; i<FRAME_SIZE; i++)
        rawin[i] = pcm2[i];

    speex_bits_reset(&enc_bits);
    speex_preprocess_run(preprocess, rawin);
   #endif
#endif
}

void SanSpeexEnc::captureEcho(short *rawin, short *playback)
{
#ifdef ENABLE_AEC
    speex_echo_cancellation(echo_state, rawin, playback, pcm2);
    speex_preprocess_run(preprocess, pcm2);
    for (int i=0; i<FRAME_SIZE; i++)
        rawin[i] = pcm2[i];
#endif
}

//==================================================
SanSpeexDec::SanSpeexDec()
            :dec_state(0),
             dec_bits(),
             speexenc(0),
             jitter(),
             mostUpdatedTSatPut(0),
             firsttimecalling_get(true)
{
    for (int i=0; i<FRAME_SIZE; i++)
        pcm[i] = 0;
    int tmp;

    dec_state = speex_decoder_init(&speex_wb_mode);
    tmp = 1;
    speex_decoder_ctl(dec_state, SPEEX_SET_ENH, &tmp);
    speex_bits_init(&dec_bits);
    speex_jitter_init(&jitter, dec_state, SAMPLING_RATE);
}

SanSpeexDec::~SanSpeexDec()
{
speex_jitter_destroy(&jitter);

//–Destroy the decoder state
speex_decoder_destroy(dec_state);

//–Destroy the bit-stream truct
speex_bits_destroy(&dec_bits);
}

void SanSpeexDec::setSanSpeexEnc(SanSpeexEnc *ptr)
{
speexenc = ptr;
}

int SanSpeexDec::put(const char *encodedBufWithTimestamp, int encodedLenWithTimestamp)
{
    //buffer:
    // timestamp | encodedBuf
    // ———–+——————————
    //   4        | encodedLenWithTimestamp – 4
    int success = 0;
    int recv_timestamp = ((int*)encodedBufWithTimestamp)[0];
    mostUpdatedTSatPut = recv_timestamp;
    if (firsttimecalling_get)
        return 1;
    speex_jitter_put(&jitter, (char *)encodedBufWithTimestamp+4, encodedLenWithTimestamp-4, recv_timestamp);
    return 1;
}

int SanSpeexDec::get(short *rawout)
{
    if (firsttimecalling_get)
    {
        int ts = mostUpdatedTSatPut;
        sprintf(msg, “MostUpdatedTSatPut = %d\n”, ts);
        debugPrint(msg);
        firsttimecalling_get = false;
        speex_jitter_get(&jitter, rawout, &ts);
    }
    else
        speex_jitter_get(&jitter, rawout, 0);
    return 1;
}

int SanSpeexDec::afterPlayback(short *rawin, bool ok)
{
    if (speexenc)
        return speexenc->playbackEcho(rawin, ok);
    return 0;
}

Testing portaudio and speex - part 2

slworkthings — Wed, 11 Nov 2009 00:32:56 +0000

Continue.

AudioClient header file:
#include “mysocket.h”

//==============================================================
MySocket::MySocket(const QString& myId)
         :m_socketdevice(0),
          m_running(false),
          m_amIClient(true),
          m_buf(0),
          m_bufLen(1024),
          m_myId(myId)
{
    m_socketdevice = new QSocketDevice();
    m_socketdevice->setAddressReusable(true);
    m_socketdevice->setBlocking(true);

m_buf = new char[m_bufLen];
}

MySocket::~MySocket()
{
stop();

delete m_socketdevice;
m_socketdevice = 0;

delete [] m_buf;
m_buf = 0;
}

void MySocket::setId(const QString& id)
{
m_myId = id;
}

void MySocket::stop()
{
    if (m_running)
    {
        m_running = false;
    }
    if (m_socketdevice)
        m_socketdevice->close();
    //wait(500);
    qDebug(“MySocket::stop”);
}

bool MySocket::connectTo(const QString& serverAddr, int port)
{
    m_amIClient = true;
    if (!m_socketdevice)
        return false;

    bool ok = m_socketdevice->connect(serverAddr, port);
    wait(1000);
    if (ok)
    {
        QString handshake = “myid=” + m_myId;
        send(handshake);
    }
    return ok;
}

void MySocket::setSocket(int socket)
{
m_amIClient = false;
m_socketdevice->setSocket(socket, QSocketDevice::Stream);
}

bool MySocket::hasError()
{
    if (!m_socketdevice)
        return true;
    return (m_socketdevice->error() != QSocketDevice::NoError);
}

void MySocket::run()
{
m_running = true;

    if (m_socketdevice)
    {
        qDebug(“port/peerPort = %d,%d”, m_socketdevice->port(), m_socketdevice->peerPort());
    }

    int len = 0;
    int readLen = 0;
    while (m_running && m_socketdevice && !hasError())
    {
        len = m_socketdevice->bytesAvailable();
        if (len > 0)
        {
            if (len > m_bufLen)
            {
                m_bufLen = len;
                delete [] m_buf;
                m_buf = new char[m_bufLen];
            }

            readLen = m_socketdevice->readBlock(m_buf, len);
            if (readLen <= 0) //error
            {
                qDebug(“—– read error — 1″);
                m_running = false;
                break;
            }
            while (readLen < len && !hasError())
            {
                int curLen = m_socketdevice->readBlock(m_buf + readLen, len – readLen);
                if (curLen <= 0) //error
                {
                    qDebug(“—– read error — 3″);
                    m_running = false;
                    break;
                }
                readLen += curLen;
            }
            if (!m_running)
                break;

            QByteArray ba(len);
            const char *data = ba.data();
            memcpy(ba.data(), m_buf, len);
            if (len > 5 && data[0] == ‘m’ && data[1] == ‘y’ && data[2] == ‘i’ && data[3] == ‘d’ && data[4] == ‘=’)
            {
                QString handshake(ba);
                QString hisId = handshake.mid(5);
                emit fireReceivedHandshake(m_socketdevice->socket(), hisId);
            }
            else if (len > 3 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’ && data[3] == ‘Q’)
            {
                m_running = false;
                qDebug(“MySocket::run() got cmdQ”);
                emit fireReceivedData(ba);
            }
            else
                emit fireReceivedData(ba);
        }
        else
        {
            len = m_socketdevice->waitForMore(100);
            if (len == -1 || hasError()) //error
            {
                qDebug(“—– read error — 2″);
                m_running = false;
                break;
            }
        }
    }//while()
    qDebug(“—– done MySocket::run() —-”);
}//run()

bool MySocket::send(const QByteArray& ba)
{
    bool success = false;
    if (!m_socketdevice)
        return success;

    const char *data = ba.data();
    int len = ba.size();
    int writtenLen = 0;

    writtenLen = m_socketdevice->writeBlock(data, len);
    while (writtenLen < len)
    {
        writtenLen += m_socketdevice->writeBlock(data + writtenLen, len – writtenLen);
    }

return (writtenLen == len);
}

bool MySocket::send(const QString& str)
{
    QCString cstr = str.utf8();
    const char *data = (const char *)(cstr);
    QByteArray ba(cstr.length());
    memcpy(ba.data(), data, cstr.length());

    return send(ba);
}
//=====================================================
MyServerSocket::MyServerSocket(Q_UINT16 port)
               :QServerSocket(port),
                m_mysocketDict(), //key=socket(int)
                m_map() //socket(int), id(Qstring)
{
    m_mysocketDict.setAutoDelete(true);
}

MyServerSocket::~MyServerSocket()
{
m_mysocketDict.clear();
m_map.clear();
}

void MyServerSocket::newConnection(int socket)
{
    MySocket *mysocket = new MySocket();
    connect(mysocket, SIGNAL(fireReceivedData(const QByteArray&)),
                      SIGNAL(fireReceivedData(const QByteArray&)));
    connect(mysocket, SIGNAL(fireReceivedHandshake(int, const QString&)),
                      SLOT(slotReceivedHandshake(int, const QString&)));
    m_map.insert(socket, QString(“”));
    m_mysocketDict.insert(QString::number(socket), mysocket);
    mysocket->setSocket(socket);
    mysocket->start();
}

bool MyServerSocket::send(const QByteArray& ba, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(ba);
            }
        }
    }
    return false;
}

bool MyServerSocket::send(const QString& str, const QString& _id)
{
    QMap<int, QString>::Iterator it;
    for (it = m_map.begin(); it != m_map.end(); ++it)
    {
        int key = it.key();
        QString id = it.data();
        if (id == _id) //found it
        {
            MySocket *sock = m_mysocketDict.find(QString::number(key));
            if (sock)
            {
                return sock->send(str);
            }
        }
    }
    return false;
}

void MyServerSocket::stop()
{
    QDictIterator<MySocket> it(m_mysocketDict);
    MySocket *sock = 0;
    for ( ; (sock = it.current()); ++it)
    {
        sock->stop();
    }
}

void MyServerSocket::slotReceivedHandshake(int socket, const QString& hisId)
{
    qDebug(“—- receive handshake :” + QString::number(socket) + ” =” + hisId);
    m_map.insert(socket, hisId, true);
    MySocket *sock = m_mysocketDict.find(QString::number(socket));
    if (sock)
    {
        sock->setId(hisId);
        emit fireReceivedHandshake(hisId);
    }
}

AudioClient source file:

#include “audioclient.h”
#include <qpushbutton.h>
#include <qlabel.h>
#include <qlayout.h>
#include <qlineedit.h>
#include <qapplication.h>

//===================================
AudioClient::AudioClient(int serverPort, bool isRecorder)
            :QWidget(),
             m_socket(0),
             m_setBtn(0),
             m_startBtn(0),
             m_stopBtn(0),
             m_edit(0),
             m_isRecorder(isRecorder)
{
    m_socket = new MySocket(isRecorder ? “recorder” : “playback”);
    connect(m_socket, SIGNAL(fireReceivedData(const QByteArray&)),
                      SLOT(slotReceivedData(const QByteArray&)));

QVBoxLayout *vlayout = new QVBoxLayout(this);

    QHBoxLayout *h1 = new QHBoxLayout(0);
    QLabel *label1 = new QLabel(“Set Device Index:”, this);
    m_edit = new QLineEdit(this);
    m_edit->setText(isRecorder ? “1″ : “7″);
    m_setBtn = new QPushButton(isRecorder ? “Set Capture Dev” : “Set Playback Dev”, this);
    h1->addWidget(label1);
    h1->addWidget(m_edit);
    h1->addWidget(m_setBtn);
    vlayout->addItem(h1);

    QHBoxLayout *h2 = new QHBoxLayout(0);
    QLabel *label2 = new QLabel(isRecorder ? “Start Capture” : “Start Playback”, this);
    m_startBtn = new QPushButton(“Start”, this);
    h2->addWidget(label2);
    h2->addWidget(m_startBtn);
    vlayout->addItem(h2);

    QHBoxLayout *h3 = new QHBoxLayout(0);
    QLabel *label3 = new QLabel(isRecorder ? “Stop Capture” : “Stop Playback”, this);
    m_stopBtn = new QPushButton(“Stop”, this);
    h3->addWidget(label3);
    h3->addWidget(m_stopBtn);
    vlayout->addItem(h3);

QPushButton *exitBtn = new QPushButton(“Exit”, this);
vlayout->addWidget(exitBtn);

    connect(m_setBtn,   SIGNAL(clicked()), SLOT(slotSetClicked()));
    connect(m_startBtn, SIGNAL(clicked()), SLOT(slotStartClicked()));
    connect(m_stopBtn, SIGNAL(clicked()), SLOT(slotStopClicked()));
    connect(exitBtn,    SIGNAL(clicked()), SLOT(slotExitClicked()));

move(isRecorder ? 30 : 130, isRecorder ? 30 : 130);
setCaption(isRecorder ? “RecorderClient” : “PlaybackClient”);

    bool ok = m_socket->connectTo(“127.0.0.1″, serverPort);
    qDebug(“connect to = %d”, ok);
    if (ok)
        m_socket->start();
}

AudioClient::~AudioClient()
{
delete m_socket;
m_socket = 0;
}

void AudioClient::slotSetClicked()
{
    QString str = m_isRecorder ? “cmd2″ : “cmd3″;
    str += m_edit->text().stripWhiteSpace();
    m_socket->send(str);
    m_setBtn->setEnabled(false);
}

void AudioClient::slotStartClicked()
{
m_socket->send(m_isRecorder ? “cmd4″ : “cmd5″);
m_startBtn->setEnabled(false);
}

void AudioClient::slotStopClicked()
{
m_socket->send(m_isRecorder ? “cmd6″ : “cmd7″);
m_stopBtn->setEnabled(false);
}

void AudioClient::slotExitClicked()
{
    if (m_socket && m_socket->isValid())
    {
        m_socket->send(“cmdQ”);
        m_socket->stop();
    }
    close();
    qApp->quit();
}

void AudioClient::closeEvent(QCloseEvent *)
{
    if (m_socket && m_socket->isValid())
    {
        m_socket->send(“cmdQ”);
        m_socket->stop();
    }
    qApp->quit();
}

void AudioClient::slotReceivedData(const QByteArray& ba)
{
    const char *data = ba.data();
    if (ba.size() >= 4 && data[0] == ‘c’ && data[1] == ‘m’ && data[2] == ‘d’)
    {
        char cmd = data[3];
        switch (cmd)
        {
        case ‘1′: //return device list;   dev1\ndev2\n…
            {
                QString devList(ba);
                devList = devList.mid(4);
                qDebug(“1. DevList = ” + devList);
            }
            break;
        case ‘2′: //set recorder device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“2. RecorderDevice = ” + devName);
            }
            break;
        case ‘3′: //set playback device; devname
            {
                QString devName(ba);
                devName = devName.mid(4);
                qDebug(“3. PlaybackDevice = ” + devName);
            }
            break;
        case ‘4′: //start recorder
            qDebug(“4. Start Recording”);
            break;
        case ‘5′: //start playback
            qDebug(“5. Start Playback”);
            break;
        case ‘6′: //stop recorder
            qDebug(“6. Stop Recording”);
            break;
        case ‘7′: //stop playback
            qDebug(“7. Stop Playback”);
            break;
        case ‘Q’:
            qDebug(“Q. Quit”);
            slotExitClicked();
            break;
        default:
            break;
        }
    }//cmd
    else
    {
        if (ba.size() >
        {
            const char *data = ba.data();
            int packetSize = ((int*)data)[0];
            int timestamp = ((int*)data)[1];
            qDebug(“got packetSize=%d, timestamp=%d”, packetSize, timestamp);
        }
    }
}//slotReceivedData()

Testing portaudio and speex - part 1

slworkthings — Wed, 11 Nov 2009 00:31:08 +0000

This is a testing program I wrote in QT3 to test audio capture/playback loop in a local machine. Using 2 testing clients to communicate with AudioEngine which handling audio capturing/playing. Of course, need a lot of improvement on audio quality and AGC, AEC… ,etc.

socket header file:
#ifndef _MYSOCKET_H_
#define _MYSOCKET_H_

#include <qsocketdevice.h>
#include <qthread.h>
#include <qobject.h>
#include <qserversocket.h>
#include <qdict.h>
#include <qmap.h>

//==============================================
class MySocket : public QObject, public QThread
{
    Q_OBJECT
public:
    MySocket(const QString& myId = QString::null);
    ~MySocket();

//I am client
bool connectTo(const QString& serverAddr, int port);

    //I am server
    void setSocket(int socket);
    void setId(const QString& id);

    bool send(const QByteArray&);
    bool send(const QString& str);
    void stop();

bool isValid() { return (m_socketdevice && m_socketdevice->isValid()); }

signals:
void fireReceivedData(const QByteArray&);
void fireReceivedHandshake(int socket, const QString&);

protected:
virtual void run();

private:
bool hasError();

    QSocketDevice   *m_socketdevice;
    bool             m_running;
    bool             m_amIClient;
    char            *m_buf;
    int              m_bufLen;
    QString          m_myId;
};
//=====================================================
class MyServerSocket : public QServerSocket
{
    Q_OBJECT
public:
    MyServerSocket(Q_UINT16 port = 4242);
    ~MyServerSocket();

    bool send(const QByteArray&, const QString& id);
    bool send(const QString&, const QString& id);
    void stop();

signals:
void fireReceivedData(const QByteArray&);
void fireReceivedHandshake(const QString& hisId);

private slots:
void slotReceivedHandshake(int socket, const QString& hisId);

protected:
virtual void newConnection(int socket);

private:
QDict<MySocket> m_mysocketDict; //key=socket(int)
QMap<int, QString> m_map;
};
#endif // _MYSOCKET_H_

socket source file:
#include “mysocket.h”

m_buf = new char[m_bufLen];
}

MySocket::~MySocket()
{
stop();

delete m_socketdevice;
m_socketdevice = 0;

delete [] m_buf;
m_buf = 0;
}

void MySocket::setId(const QString& id)
{
m_myId = id;
}

void MySocket::stop()
{
    if (m_running)
    {
        m_running = false;
    }
    if (m_socketdevice)
        m_socketdevice->close();
    //wait(500);
    qDebug(“MySocket::stop”);
}

bool MySocket::connectTo(const QString& serverAddr, int port)
{
    m_amIClient = true;
    if (!m_socketdevice)
        return false;

    bool ok = m_socketdevice->connect(serverAddr, port);
    wait(1000);
    if (ok)
    {
        QString handshake = “myid=” + m_myId;
        send(handshake);
    }
    return ok;
}

void MySocket::setSocket(int socket)
{
m_amIClient = false;
m_socketdevice->setSocket(socket, QSocketDevice::Stream);
}

bool MySocket::hasError()
{
    if (!m_socketdevice)
        return true;
    return (m_socketdevice->error() != QSocketDevice::NoError);
}

void MySocket::run()
{
m_running = true;

    if (m_socketdevice)
    {
        qDebug(“port/peerPort = %d,%d”, m_socketdevice->port(), m_socketdevice->peerPort());
    }

bool MySocket::send(const QByteArray& ba)
{
    bool success = false;
    if (!m_socketdevice)
        return success;

    const char *data = ba.data();
    int len = ba.size();
    int writtenLen = 0;

    writtenLen = m_socketdevice->writeBlock(data, len);
    while (writtenLen < len)
    {
        writtenLen += m_socketdevice->writeBlock(data + writtenLen, len – writtenLen);
    }

return (writtenLen == len);
}

bool MySocket::send(const QString& str)
{
    QCString cstr = str.utf8();
    const char *data = (const char *)(cstr);
    QByteArray ba(cstr.length());
    memcpy(ba.data(), data, cstr.length());

MyServerSocket::~MyServerSocket()
{
m_mysocketDict.clear();
m_map.clear();
}

void MyServerSocket::stop()
{
    QDictIterator<MySocket> it(m_mysocketDict);
    MySocket *sock = 0;
    for ( ; (sock = it.current()); ++it)
    {
        sock->stop();
    }
}

Art Lebedev's Rozetkus 3D Socket Cuts Down On Wires

range — Tue, 10 Nov 2009 08:03:34 +0000

Art Lebedev’s most recent project is a refresher on their Rozetkus power strip. What’s really interesting is that it’s more than just a socket. It can deploy an additional 4 sockets from its midst. Funky enough for you?

setsockopt SO_LINGER

cotton5415 — Fri, 30 Oct 2009 02:51:16 +0000

SO_LINGER:
只針對 socket 的 close() 發揮作用。
case 1 (default):
linger->l_onoff = 0; –> linger->l_linger no effect;
case 2:
linger->l_onoff !=0; linger->l_linger = 0 ;
close() immediately. 不管底層的資料是否送出，直接送一個 RST(reset)給另一端。因此另一端在 recv的時候，會產生 ECONNRESET 的 error

case 3:
linger->l_onff != 0; linger->l_linger != 0;
close() 會 block住或是等到 l_linger 的timeout時間到之後，產生 EWOULDBLOCK error

ref: http://www.developerweb.net/forum/archive/index.php/t-2982.html

Cartas e Eventos. Comunicação entre módulos em C.

guilhermealexs — Wed, 28 Oct 2009 02:21:09 +0000

Bem que C poderia ser como Java, não é? Acabo de bater três vezes na madeira aqui ao lado. Mais uma para ter certeza. De qualquer maneira, pouco me importa C ou Java (só não aceito Delphi). O fato é que C obriga o programador a implementar por conta própria recursos que já são de base em outras linguagens. Sim, isso é lindo.

Vejam bem, estava implementando um servidor GPRS que precisava manter uma conexão TCP. Para isso, abri mão das threads e trabalhei assincronamente utilizando a função select (não é a mais eficiente, mas precisava ter um certa compatibilidade com UNIX). O problema de não usar threads é que isso tende a centralizar o código, forçando a utilização das mensagens trocadas onde se implementa a própria rede.

Bem, eis o que fiz para descentralizar o código. A coisa foi parecida com um esquema de eventos, mas com nomes diferentes. Tudo começa quando o módulo de rede (que roda numa thread) recebe mensagens. Essas mensagens são enfileiradas num formato específico, geralmente contendo a mensagem recebida e algum outro parâmetro, que então serão eventualmente lidas e retiradas da fila por algum outro módulo do sistema. Dando nome aos bois:

Mensagens de rede (recebidas): Cartas
Fila de mensagens: Caixa Postal

É isso. A vantagem disso tudo é que o código fica mais limpo, torna a separação em módulos mais bonita e natural.

We have over 1,000 BGA footprints online. Search, select, and build a part number at www.bgasockets.com

Advanced Interconnections — Tue, 27 Oct 2009 16:16:53 +0000

One of over 1,000 BGA footprints available in our fully searchable online database.

BGA Socket Finder™ is an interactive database of over 1,000 Ball Grid Array footprints ranging in pitch from 0.50mm to 1.27mm. Engineers from around the world use this online database every day to search for their device footprints by pin count, pitch, package size, or row count. The more criteria you enter, the more refined your search results will be. Use the footprint number to build a part number for the exact BGA socket or adapter required for your application. Footprint-specific data sheets and CAD drawings available online. Access to the database is free with registration. Start your search at www.bgasockets.com.

A multi-threaded socket-based server

cheetim — Sun, 18 Oct 2009 06:38:39 +0000

The problem is old – How to implement a multi-threaded, socket-based server that will let you read and write to the client (for example a telnet terminal.

There are several problems with constructing such a server:

You have to use threads because otherwise clients will be queued up waiting for a connection.
Many of the publicly available examples (even some in some books) do not work for I/O servers. They are mostly developed around reading from a socket not writing to the socket as well. In our example we give a working read/write code example.
You need to avoid race conditions when starting up a thread at times when connections are coming through thick and fast.

The code below will implement just such a server. It is intended for a head start, so is a template rather than a tutorial on how to write a server in Java. We have decided on port 4444 to listen on in the example, but you need to decide on a suitable port yourself.

The server will run, establishing connections from the port and echoing input received until it receives a line of input that is a full stop only “.”.

The Kieser.net team.
Honeypot: spam@kieser.net
http://www.kieser.net/linux/java_server.html


import java.io.*;
import java.net.*;

/**
 * Title:        Sample Server
 * Description:  This utility will accept input from a socket, posting back to the socket before closing the link.
 * It is intended as a template for coders to base servers on. Please report bugs to brad at kieser.net
 * Copyright:    Copyright (c) 2002
 * Company:      Kieser.net
 * @author B. Kieser
 * @version 1.0
 */
public class sample_server {

private static int port=4444, maxConnections=0;

// Listen for incoming connections and handle them

public static void main(String[] args) {

int i=0;

try{
ServerSocket listener = new ServerSocket(port);
Socket server;

while((i++ < maxConnections) || (maxConnections == 0)){
doComms connection;

server = listener.accept();
doComms conn_c= new doComms(server);
Thread t = new Thread(conn_c);
t.start();
}
} catch (IOException ioe) {
System.out.println("IOException on socket listen: " + ioe);
ioe.printStackTrace();
}
}

}

class doComms implements Runnable {
 private Socket server;
 private String line,input;

 doComms(Socket server) {
 this.server=server;
 }

 public void run () {

 input="";

 try {
 // Get input from the client
 DataInputStream in = new DataInputStream (server.getInputStream());
 PrintStream out = new PrintStream(server.getOutputStream());

 while((line = in.readLine()) != null && !line.equals(".")) {
 input=input + line;
 out.println("I got:" + line);
 }

 // Now write to the client

 System.out.println("Overall message is:" + input);
 out.println("Overall message is:" + input);

 server.close();
 } catch (IOException ioe) {
 System.out.println("IOException on socket listen: " + ioe);
 ioe.printStackTrace();
 }
 }
}

Replacing the costly hand-loading of socket terminals with customizable Peel-A-Way® Removable Terminal Carriers just got easier.

Advanced Interconnections — Tue, 13 Oct 2009 19:43:02 +0000

In addition to traditional single-, dual-, triple-row and grid array patterns, Advanced Interconnections Corp. now offers its extensive line of Peel-A-Way^® removable terminal carriers in nonlinear configurations.

The RoHS-compliant polyimide film carriers can be ordered in a wide variety of shapes, patterns and pin spacing

Peel-A-Way® Removable Terminal Carrier

to suit virtually any through-hole or press-fit application. Unique configurations with random pin patterns and multiple terminal styles on a single carrier can be quickly designed to meet application requirements. Cutouts can be included to provide for component clearance or heat dissipation.

Peel-A-Way carriers feature a lightweight, ultra-low-profile insulator (only .005″ (0.13mm) thick), suitable for automated pick-and-place. Supplied with Advanced^® screw-machined terminals for superior reliability, Peel-A-Way carriers can be easily removed after soldering for complete visibility or left in place for added stability. Multiple terminal styles can be loaded on a single carrier, saving time and eliminating the potential for error associated with hand-loading individual pins on PC boards. Standard and custom terminal styles are available in a variety of plating options. Standard socket terminals accept leads as small as .010″ (.25mm) and as large as .102″ (2.59mm) and are available with optional solder preforms, which eliminate the need for wave soldering in an SMT environment.
Pricing and lead time vary based on terminal selection and quantity.

Advanced Interconnections Corporation is an ISO 9001 Certified designer and manufacturer of electronic interconnect solutions, with world headquarters located in Rhode Island (USA). For more information, visit www.advanced.com or contact Advanced Interconnections’ customer service department at: 5 Energy Way, West Warwick, RI 02893 USA. Tel: (800) 424-9850 or (401) 823-5200 or Fax: (401) 823-8723. E-mail: info@advanced.com. Product information available online at www.advanced.com/peel.

Peel-A-Way is a registered trademark of Advanced Interconnections Corp.

libevent+protobuf轻松搭建tcpserver

superangevil — Mon, 12 Oct 2009 04:36:08 +0000

0. 基础代码

// 设置某fd为O_NONBLOCK模式
int set_non_block(int fd);

// server端socket流程:socket(),setsockopt(),bind(),listen(),set_non_block()，返回server_fd
int setup_tcp_server(int port);

// client端socket流程:socket(),connect()，返回连接的sockfd
int create_io_channel(const char *ipaddr, int port);

1. 搭建TCP Server
下面以伪代码方式给出，错误处理省略

      int main(int argc, char *argv[])
      {
          // 初始化
          …

          // event初始化
          event_init();
          init_server(port, params…);
          event_dispatch();

return 0;
}

      int init_server(short port, params…)
      {
          int listen_fd = setup_tcp_server(port);
          set_non_block(listen_fd);

          // 将输入的参数params… 组织为一个结构，以指针的方式存于accept_param
          struct event* ev_accept = (struct event*)malloc(sizeof(struct event));
          event_set(ev_accept, listen_fd, EV_READ|EV_PERSIST, on_accept, (void*)accept_param);
          event_add(ev_accept, NULL);

return 0;
}

      void on_accept(int fd, short ev, void *arg)
      {
          int client_fd = accept(fd, (struct sockaddr*)&client_addr, &client_len);
          set_non_block(client_fd);

          // Disable the Nagle (TCP No Delay) algorithm
          int flag = 1;
          int ret = setsockopt(client_fd, IPPROTO_TCP, TCP_NODELAY, (char*)&flag, sizeof(flag));

          // 设置buffer event
          // 假设client_t有一个类型为struct bufferevent*的域buf_ev
          //     total_len: 指示请求总长度
          //     cur_size: 指示当前已经接收的请求长度
          //     data:      请求数据本身
          client_t *client = (client_t*)malloc(sizeof(client_t));
          client->buf_ev = bufferevent_new(client_fd, buffer_on_read, buffer_on_write, buffer_on_error, client);
          client->total_len = 0;
          client->cur_size = 0;
          client->data = NULL;
          bufferevent_enable(client->buf_ev, EV_READ|EV_WRITE);
      }

      void buffer_on_read(struct bufferevent *ev_buf, void *opqaue)
      {
          // 读请求并处理

          client_t *client = (client_t*)opaque;
          size_t rdsz;
          int sz;

if (client->total_len <= client->cur_size) {
// 读新请求

              // 获得新请求的总长度
              rdsz = bufferevent_read(ev_buf, &sz, sizeof(int));
              client->total_len = sz;

              // 开始读新请求数据(一次不一定能读完!)
              char *data = (char*)malloc(sz);
              rdsz = bufferevent_read(ev_buf, data, sz);
              client->cur_size = (int)rdsz;
              client->data = data;
          } else {
              // 继续读该请求
              rdsz = bufferevent_read(ev_buf, client->data+client->cur_size, client->total_len-client->cur_size);
              client->cur_size += (int)rdsz;
          }

          if (client->cur_size >= client->total_len) {
              // 处理该(完整的)请求
              request_t req;   // 请求的数据结构(通过protobuf定义)
              response_t res;   // 回应的数据结构(通过protobuf定义)

              // 调用处理函数对request进行处理,并把结果写到response中
              req.ParseFromArray((const void*)client->data, client->total_len);
              process_func(req, res);

              // 写回应
              string output;
              res.SerializeToString(&output);
              int status = bufferevent_write(ev_buf, output.c_str(), output.length());
          }
      }

      void buffer_on_write(struct bufferevent *ev_buf, void *opqaue)
      {
          // 作清理工作

          client_t *client = (client_t*)opaque;
          if (client->data && strlen(client->data) != 0)
              free(client->data);
          client->data = NULL;
          client->total_len = 0;
          client->cur_size = 0;
      }

      void buffer_on_error(struct bufferevent *ev_buf, short what, void *opqaue)
      {
          // 给出错误信息
          division_client *client = (division_client*)opaque;
          struct sockaddr_in client_addr;
          socklen_t len = sizeof(client_addr);
          if (getpeername(client->sock_fd, (struct sockaddr*)&client_addr, &len) == 0)
              LOG_INFO(“Client(%s:%u) connection closed or Error occured — %d\n”,
                      inet_ntoa(client_addr.sin_addr),
                      ntohs(client_addr.sin_port),
                      what);
          else
              LOG_INFO(“Client(unknown) connection closed or Error occured — %d\n”, what);

          if (client) {
              if (client->data)
                  free(client->data);
              free(client);
          }
      }

2. protobuf作为client与server之间的数据传输协议

详见 http://code.google.com/apis/protocolbuffers/

Emule ID basso

faberex — Tue, 06 Oct 2009 17:19:01 +0000

Giusto per chiarire le idee su una funzione vitale, vediamo di fare un piccolo riassunto sui possibili “Perché” di un ID Basso.

Controllare se avete configurato il firewall di XP o Vista. E’ preferibile disabilitare del tutto il firewall integrato di Windows XP e utilizzare uno esterno . Si consiglia Outpost ( con Options,Plugin,Setup,Stop su tutti) Segate e Zone Alarm per la facilità di configurazione e l’assenza di malfunzionamenti ; installatelo e poi procedete alla loro configurazione
Controllate se avete un router e configuratelo
Se continuate ad avere ID Basso domandatevi se vi serve davvero un router .Se avete un solo PC non vi serve .Procuratevi , piuttosto , un Modem USB per pochi euro.
GRPS,ADSL Satellitare e UMTS avranno comunque un ID Basso
In caso disperato provate a chiedere sul canale ufficiale di aiuto raggiungibile dal pulsante IRC di eMule ,ma ricordatevi che configurare un router è operazione lunga e noiosa e che dovrete cavarvela da soli più che potrete ,perché ci sono multi utenti e pochi operatori in grado di aiutarvi. Il server , quando vi collegate , assegna l’ID ALTO (maggiore di 16777216) con un semplice calcolo a partire dal vostro IP (Indicato con A.B.C.D.): IP = A.B.C.D.>ID = A+256* B+256*256*C+256*256*256*D. Il server assegna ID Basso con un numero progressivo che parte da 1 per il primo eMule con ID Basso che si collega a lui e che aumenta via via per ogni altro utente con ID Basso successivo (NON DIPENDE PERCIO’ DALL’ IP)
Se nonostante i vostri tentativi nulla accade, ecco una dritta per cercare un’ulteriore aiuto http://zirconet.wordpress.com/ ottimo blog di notizie e con perle tecniche per trarsi dagl’impicci .Il blog non e’ tra i più conosciuti data la sua recente comparsa ma l’autore è persona attenta e disponibile e quel che più conta risponde sempre ai quesiti inviatogli.

Qui qualche piccola ulteriore delucidazioni su alcuni termini usati.

IP: E’ l’indirizzo del vostro pc su internet, indispensabile per poter comunicare con altri computer. Viene assegnato quando vi collegate alla rete. Collegatevi al sito www-ip.com e potrete vedere il vostro. E’ bene sapere che tutti i pacchetti di dati che arrivano al nostro pc contengono solo il nostro IP, perché la rete di distribuzione conosce dove siamo e ci manda solo pacchetti i coretti ( e questo se ben pensate la dice lunga sull’effettiva privacy di Internet , ma questo e’ un altro discorso) Tutti gli IP si scrivono a gruppi di tre cifre (da 0 a 255) separati da un punto , per esempio 235.158.2.96. Non potete scegliere l’ IP che vi viene assegnato ,perche’ sono stati acquistati dalle compagnie telefoniche e attribuiti a loro piacimento quando vi collegate. Sono detti IP pubblici perché i pc che li possiedono possono parlare direttamente su internet tra loro.

Per Router o reti locali:

I seguenti intervalli di IP sono detti privati perchè non vengono utilizzati su internet ma solo per creare delle reti locali collegando più pc tra loro (LAN)

Esempio ; 10.x.x.x

192.168.x.x

da……….. 172.16.0.0 a 172.31.255.25

Ogni LAN , se vuole comunicare su internet deve avere anche un Gateway ,cioe’ un router oppure un pc ( che chiamiamo server) collegato a internet con un modem e un programma apposito ( ad esempio ICS,Già incluso in Windows) Solo il gateway ha 2IP : uno pubblico assegnato al momento della connessione e uno privato come tutti gli altri pc della LAN (esempio gateway con 235.158.2.96 e 10.0.0.1, gli altri Pc 10.0.0.2,10.0.0.3 ecc ,ecc.) Gli altri pc nel mondo non sanno che avete molti computer collegati perché vedranno solo l’IP pubblico del gateway.Quindi quando uno dei pc della LAN deve spedire dei dati , il gateway cambia nei pacchetti l’IP del pc che ha effettuato la trasmissione con quello pubblico e li spedisce, memorizzando inoltre quale porta ha utilizzato il pc . In ricezione tutti i dati che arrivano vengono smistati ai vari Pc della rete locale dal gateway ,perché ricorda quale porta sta utilizzando ogni pc interno . Questo meccanismo di sostituzione di IP e smistamento viene detto funzione di NAT. Ovviamente , i pc della rete locale sanno che devono passare attraverso il router o il server (cioè il gateway) perciò utilizzano automaticamente porte diverse tra di loro per parlare con il router , in modo da non aver conflitti. Il problema di ID Basso , in questi casi può essere risolto configurando il router o l’ICS di windows. In una rete locale , normalmente gli ADSL router svolgono tutte le tre funzioni : ethernet hub + router con NAT + MODEM ADSL . quindi voi vedete solo un apparecchio . Il router serve per la conversione IP PUBBLICO/IP PRIVATO , il modem manda segnali elettrici e dialoga sul cavo di rame con il modem della centrale telefonica che e’ dall’altro estremo della linea ADSL.

Porta

E’ il numero che va da 0 a 65535 e serve ai pc per capire a che programma devono essere deviati tutti i dati che arrivano fra quelli che funzionano sul pc .possiamo pensare che se il pc fosse un condominio , l’IP SAREBBE L’INDIRIZZO DELL’EDIFICIO .La porta la possiamo immaginare come uno degli appartamenti interni all’edificio in cui ogni appartamento è un programma che vuole comunicare con internet. Ogni pacchetto dati che vi arriva possiede non solo l’indirizzo IP del vostro pc , ma anche la porta di destinazione per il programma che deve riceverlo. Alcune porte sono standard , come per esempio la 80 per i server web . la 25 e la 110 per i server della posta . Quando usate Internet Explorer , il vostro pc apre una porta a caso fra quelle non ancora utilizzate e si collega sempre alla porta 80 del server che ospita il sito che state visitando . SE si deve specificare una porta a mano , si usa scrivere IP: porta . Esempio 235.158.2.96:1456( indica la porta 1456 sul pc con indirizzo 235.158.2.96) tale combinazione di IP+ porta è detta “SOCKET”

Provate con il programma TCPWiew . Una versione più rozza è incorporata dentro windows basta fare :

START, ESEGUI ,CMD ; ora nella finestra scrivete Netstat seguito da invio e il gioco e’ fatto.

E’ un numero calcolato dal server di emule a cui vi collegate , di solito determinato dall’IP che avete su internet

Firewall

Programma che serve a bloccare le intrusioni al vostro pc mentre siete collegati su internet , chiudendo tutte le porte non utilizzate e spesso consentono di bloccare o autorizzare i singoli programmi che chiedono di comunicare su internet( potrebbero essere trojan o spyware che vi hanno infettato) Il firewall genera quindi una linea di difesa tra il vostro pc e la rete con l’obiettivo finale di controllare il flusso di informazioni che partano e arrivano al computer per verificare se queste seguono o meno criteri legittimi. Non appena un informazione esce da questi criteri , il firewal entra in azione e consente se bloccare o meno un particolare scambio di dati.

PS: Chiaro è , che tutto quanto scritto sopra va considerato in linea di massima, tutti più o meno abbiamo avuto a che fare con delle “strane presenze “ dentro i nostri pc ( accorgersi è già da considerarsi come una fortuna)

Il firewal più potente è, e rimane la vostra prudenza.

Mill-Max Enhances Custom Socket Receptacles

primson — Mon, 05 Oct 2009 21:45:07 +0000

Mill-Max has introduced threading and tapping capabilities (in metric and inch sizes) for implementation on custom socket receptacles. For specialised applications requiring a non-soldered, field-replaceable interconnect, such as a socket location terminated on a metal plate, threaded or tapped pin receptacles can offer a solution. Tapping the interior back-hole of a receptacle allows for the screw attachment of threaded mating pins.

The company can provide design solutions for both threaded pins and matching tapped receptacle (or vice versa) for field-replaceable interconnect applications. Mill-Max receptacles are precision machined using brass alloy 360 1/2 hard, which offers conductive and thermal properties. Every receptacle is press-fit assembled with a beryllium copper contact, available in 36 different sizes to accept a range of mating pins measuring 0.008in to 0.102in (0.2mm to 2.59mm) in diameter.

k-d tools 2533 socket holder rack set

banrong34 — Mon, 05 Oct 2009 02:04:20 +0000

Buy Cheap K-D Tools 2533 Socket Holder Rack Set

Buy Low Price From Here Now
Neatly stores 1 4″, 3 8″, and 1 2″ square drive sockets. Mount on wall or in tool box. Each holder holds 16 sockets on movable clips. All steel construction……..
Readmore

Technical Details

– Sold Individually
See more technical details

“good socket organizer” 2009-08-29
By B. Yeung (San Francisco,CA USA)
Good price for 1/4, 3/8 and 1/2 drive socket organizer. wish they sell it in all 3/8 drive in 3 per pack.

Images Product

Buy K-D Tools 2533 Socket Holder Rack Set Now

Guía para comprar una Placa Base (Motherboard o Mainboard)

silverfenix7 — Thu, 01 Oct 2009 22:17:39 +0000

La placa base (Motherboard o Mainboard) es el soporte básico de un ordenador de ella depende varios