int MySQL_Data_Stream::write_to_net() {
int bytes_io=0;
int s = queue_data(queueOUT);
if (s==0) return 0;
VALGRIND_DISABLE_ERROR_REPORTING;
//bytes_io = ( encrypted ? SSL_write (ssl, queue_r_ptr(queueOUT), s) : send(fd, queue_r_ptr(queueOUT), s, 0) );
// splitting the ternary operation in IF condition for better readability
if (encrypted) {
bytes_io = SSL_write (ssl, queue_r_ptr(queueOUT), s);
} else {
//bytes_io = send(fd, queue_r_ptr(queueOUT), s, 0);
// fix on bug #183
bytes_io = send(fd, queue_r_ptr(queueOUT), s, MSG_NOSIGNAL);
}
VALGRIND_ENABLE_ERROR_REPORTING;
if (bytes_io < 0) {
if (encrypted==false) {
if (mypolls->fds[poll_fds_idx].revents & POLLOUT) { // in write_to_net_poll() we has remove this safety
// so we enforce it here
shut_soft();
}
} else {
int ssl_ret=SSL_get_error(ssl, bytes_io);
if (ssl_ret!=SSL_ERROR_WANT_READ && ssl_ret!=SSL_ERROR_WANT_WRITE) shut_soft();
}
} else {
queue_r(queueOUT, bytes_io);
if (mypolls) mypolls->last_sent[poll_fds_idx]=sess->thread->curtime;
bytes_info.bytes_sent+=bytes_io;
if (mybe) {
// __sync_fetch_and_add(&myds->mybe->mshge->server_bytes.bytes_sent,r);
}
}
return bytes_io;
}
void sb_device::process_fifo(UINT8 cmd)
{
if (m_cmd_fifo_length[cmd] == -1)
{
logerror("SB: unemulated or undefined fifo command %02x\n",cmd);
m_dsp.fifo_ptr = 0;
}
else if(m_dsp.fifo_ptr == m_cmd_fifo_length[cmd])
{
/* get FIFO params */
// printf("SB FIFO command: %02x\n", cmd);
switch(cmd)
{
case 0x10: // Direct DAC
break;
case 0x14: // 8-bit DMA, no autoinit
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
// printf("Start DMA (not autoinit, size = %x)\n", m_dsp.dma_length);
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 0;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = 0;
break;
case 0x17: // 2-bit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
case 0x16: // 2-bit ADPCM
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 0;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM2;
break;
case 0x1c: // 8-bit DMA with autoinit
// printf("Start DMA (autoinit, size = %x)\n", m_dsp.dma_length);
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 1;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = 0;
break;
case 0x24: // 8-bit ADC DMA
m_dsp.adc_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
// printf("Start DMA (not autoinit, size = %x)\n", m_dsp.adc_length);
m_dsp.adc_transferred = 0;
m_dsp.dma_autoinit = 0;
drq_w(1);
logerror("SB: ADC capture unimplemented\n");
break;
case 0x34:
m_uart_midi = true;
m_uart_irq = false;
break;
case 0x35:
m_uart_midi = true;
m_uart_irq = true;
break;
case 0x36:
case 0x37: // Enter UART mode
printf("timestamp MIDI mode not supported, contact MESSDEV!\n");
break;
case 0x38: // single-byte MIDI send
m_onebyte_midi = true;
break;
case 0x40: // set time constant
m_dsp.frequency = (1000000 / (256 - m_dsp.fifo[1]));
//printf("Set time constant: %02x -> %d\n", m_dsp.fifo[1], m_dsp.frequency);
break;
case 0x48: // set DMA block size (for auto-init)
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
break;
case 0x75: // 4-bit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
case 0x74: // 4-bit ADPCM
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 0;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM4;
break;
case 0x77: // 2.6-bit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
case 0x76: // 2.6-bit ADPCM
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 0;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM3;
break;
case 0xd0: // halt 8-bit DMA
m_timer->adjust(attotime::never, 0);
drq_w(0); // drop DRQ
m_dsp.dma_throttled = false;
m_dsp.dma_timer_started = false;
break;
case 0xd1: // speaker on
// ...
m_dsp.speaker_on = 1;
break;
case 0xd3: // speaker off
// ...
m_dsp.speaker_on = 0;
break;
case 0xd8: // speaker status
queue_r(m_dsp.speaker_on ? 0xff : 0x00);
break;
case 0xe0: // get DSP identification
queue_r(m_dsp.fifo[1] ^ 0xff);
break;
case 0xe1: // get DSP version
queue_r(m_dsp.version >> 8);
queue_r(m_dsp.version & 0xff);
break;
case 0xe2: // DSP protection
m_dsp.prot_value += protection_magic[m_dsp.prot_count++] ^ m_dsp.fifo[1];
m_dsp.prot_count &= 3;
m_dsp.adc_transferred = 0;
m_dsp.adc_length = 1;
m_dsp.wbuf_status = 0x80;
m_dsp.dma_no_irq = true;
m_dack_out = (UINT8)(m_dsp.prot_value & 0xff);
drq_w(1);
break;
case 0xe4: // write test register
m_dsp.test_reg = m_dsp.fifo[1];
break;
case 0xe8: // read test register
queue_r(m_dsp.test_reg);
break;
case 0xf2: // send PIC irq
irq_w(1, IRQ_DMA8);
break;
case 0xf8: // ???
logerror("SB: Unknown command write 0xf8\n");
queue_r(0);
break;
default:
if(m_dsp.version >= 0x0201) // SB 2.0
{
switch(cmd)
{
case 0x1f: // 2-bit autoinit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 1;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM2;
break;
case 0x7d: // 4-bit autoinit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 1;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM4;
break;
case 0x7f: // 2.6-bit autoinit ADPCM w/new reference
m_dsp.adpcm_new_ref = true;
m_dsp.adpcm_step = 0;
m_dsp.adpcm_count = 0;
m_dsp.dma_length = (m_dsp.fifo[1] + (m_dsp.fifo[2]<<8)) + 1;
m_dsp.dma_transferred = 0;
m_dsp.dma_autoinit = 1;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
drq_w(1);
m_dsp.flags = ADPCM3;
break;
case 0xda: // stop 8-bit autoinit
m_dsp.dma_autoinit = 0;
break;
}
}
if(m_dsp.version >= 0x0301) // SB Pro 2
{
switch(cmd)
{
case 0xe3: // copyright notice, check if in pro 2
const char* copyright = "NOT COPYRIGHT (C) CREATIVE TECHNOLOGY LTD, 1992.";
int j = strlen(copyright);
for(int k = 4; k <= j; k++)
queue_r(copyright[k]);
break;
}
}
if(m_dsp.version >= 0x0400) // SB16
{
int mode;
switch(cmd)
{
case 0x0f: // read asp reg
queue_r(0);
case 0x0e: // write asp reg
case 0x02: // get asp version
case 0x04: // set asp mode register
case 0x05: // set asp codec param
logerror("SB16: unimplemented ASP command\n");
break;
case 0x41: // set output sample rate
m_dsp.frequency = m_dsp.fifo[2] + (m_dsp.fifo[1] << 8);
break;
case 0x42: // set input sample rate
m_dsp.adc_freq = m_dsp.fifo[2] + (m_dsp.fifo[1] << 8);
break;
case 0xd5: // pause 16-bit dma
m_timer->adjust(attotime::never, 0);
drq16_w(0); // drop DRQ
m_dsp.dma_throttled = false;
m_dsp.dma_timer_started = false;
break;
case 0xd6: // resume 16-bit dma
logerror("SB: 16-bit dma resume\n");
break;
case 0xd9: // stop 16-bit autoinit
m_dsp.dma_autoinit = 0;
break;
case 0xb0:
case 0xb6:
case 0xc0:
case 0xc6:
mode = m_dsp.fifo[1];
m_dsp.flags = 0;
m_dsp.dma_length = (m_dsp.fifo[2] + (m_dsp.fifo[3]<<8)) + 1;
if((cmd & 0xf0) == 0xb0)
{
m_dsp.flags |= SIXTEENBIT;
m_dsp.dma_length <<= 1;
drq16_w(1);
}
else
drq_w(1);
if(cmd & 0x04)
m_dsp.dma_autoinit = 1;
if(mode & 0x10)
m_dsp.flags |= SIGNED;
if(mode & 0x20)
{
m_dsp.flags |= STEREO;
m_dsp.dma_length <<= 1;
}
m_dsp.dma_transferred = 0;
m_dsp.dma_timer_started = false;
m_dsp.dma_throttled = false;
break;
case 0xb8:
case 0xbe:
case 0xc8:
case 0xce:
mode = m_dsp.fifo[1];
m_dsp.adc_length = (m_dsp.fifo[2] + (m_dsp.fifo[3]<<8)) + 1;
m_dsp.adc_transferred = 0;
if(cmd & 0x04)
m_dsp.dma_autoinit = 1;
if(mode & 0x20)
m_dsp.adc_length <<= 1;
if((cmd & 0xf0) == 0xb0)
{
m_dsp.adc_length <<= 1;
drq16_w(1);
}
else
drq_w(1);
logerror("SB: ADC capture unimplemented\n");
break;
case 0xf3: // send PIC irq
irq_w(1, IRQ_DMA16);
break;
case 0xfc:
queue_r((((m_dsp.flags & SIXTEENBIT) && m_dsp.dma_autoinit) << 4) | ((!(m_dsp.flags & SIXTEENBIT) && m_dsp.dma_autoinit) << 2));
break;
}
}
}
m_dsp.fifo_ptr = 0;
}
}
int MySQL_Data_Stream::buffer2array() {
int ret=0;
bool fast_mode=sess->session_fast_forward;
if (queue_data(queueIN)==0) return ret;
if ((queueIN.pkt.size==0) && queue_data(queueIN)<sizeof(mysql_hdr)) {
queue_zero(queueIN);
}
if (fast_mode) {
queueIN.pkt.size=queue_data(queueIN);
ret=queueIN.pkt.size;
queueIN.pkt.ptr=l_alloc(queueIN.pkt.size);
memcpy(queueIN.pkt.ptr, queue_r_ptr(queueIN) , queueIN.pkt.size);
queue_r(queueIN, queueIN.pkt.size);
PSarrayIN->add(queueIN.pkt.ptr,queueIN.pkt.size);
queueIN.pkt.size=0;
return ret;
}
/**/
if (myconn->get_status_compression()==true) {
if ((queueIN.pkt.size==0) && queue_data(queueIN)>=7) {
proxy_debug(PROXY_DEBUG_PKT_ARRAY, 5, "Reading the header of a new compressed packet\n");
memcpy(&queueIN.hdr,queue_r_ptr(queueIN), sizeof(mysql_hdr));
queue_r(queueIN,sizeof(mysql_hdr));
queueIN.pkt.size=queueIN.hdr.pkt_length+sizeof(mysql_hdr)+3;
queueIN.pkt.ptr=l_alloc(queueIN.pkt.size);
memcpy(queueIN.pkt.ptr, &queueIN.hdr, sizeof(mysql_hdr)); // immediately copy the header into the packet
memcpy((unsigned char *)queueIN.pkt.ptr+sizeof(mysql_hdr), queue_r_ptr(queueIN), 3); // copy 3 bytes, the length of the uncompressed payload
queue_r(queueIN,3);
queueIN.partial=7;
mysql_hdr *_hdr;
_hdr=(mysql_hdr *)queueIN.pkt.ptr;
myconn->compression_pkt_id=_hdr->pkt_id;
ret+=7;
}
} else {
/**/
if ((queueIN.pkt.size==0) && queue_data(queueIN)>=sizeof(mysql_hdr)) {
proxy_debug(PROXY_DEBUG_PKT_ARRAY, 5, "Reading the header of a new packet\n");
memcpy(&queueIN.hdr,queue_r_ptr(queueIN),sizeof(mysql_hdr));
pkt_sid=queueIN.hdr.pkt_id;
queue_r(queueIN,sizeof(mysql_hdr));
queueIN.pkt.size=queueIN.hdr.pkt_length+sizeof(mysql_hdr);
queueIN.pkt.ptr=l_alloc(queueIN.pkt.size);
memcpy(queueIN.pkt.ptr, &queueIN.hdr, sizeof(mysql_hdr)); // immediately copy the header into the packet
queueIN.partial=sizeof(mysql_hdr);
ret+=sizeof(mysql_hdr);
// if (myconn->get_status_compression()==true) {
// mysql_hdr *_hdr;
// _hdr=(mysql_hdr *)queueIN.pkt.ptr;
// myconn->compression_pkt_id=_hdr->pkt_id;
// }
}
}
if ((queueIN.pkt.size>0) && queue_data(queueIN)) {
int b= ( queue_data(queueIN) > (queueIN.pkt.size - queueIN.partial) ? (queueIN.pkt.size - queueIN.partial) : queue_data(queueIN) );
proxy_debug(PROXY_DEBUG_PKT_ARRAY, 5, "Copied %d bytes into packet\n", b);
memcpy((unsigned char *)queueIN.pkt.ptr + queueIN.partial, queue_r_ptr(queueIN),b);
queue_r(queueIN,b);
queueIN.partial+=b;
ret+=b;
}
if ((queueIN.pkt.size>0) && (queueIN.pkt.size==queueIN.partial) ) {
if (myconn->get_status_compression()==true) {
Bytef *dest;
uLongf destLen;
proxy_debug(PROXY_DEBUG_PKT_ARRAY, 5, "Copied the whole compressed packet\n");
unsigned int progress=0;
unsigned int datalength;
unsigned int payload_length=0;
unsigned char *u;
u=(unsigned char *)queueIN.pkt.ptr;
payload_length=*(u+6);
payload_length=payload_length*256+*(u+5);
payload_length=payload_length*256+*(u+4);
unsigned char *_ptr=(unsigned char *)queueIN.pkt.ptr+7;
if (payload_length) {
// the payload is compressed
destLen=payload_length;
dest=(Bytef *)l_alloc(destLen);
int rc=uncompress(dest, &destLen, _ptr, queueIN.pkt.size-7);
assert(rc==Z_OK);
datalength=payload_length;
// change _ptr to the new buffer
_ptr=dest;
} else {
// the payload is not compressed
datalength=queueIN.pkt.size-7;
}
while (progress<datalength) {
if (CompPktIN.partial==0) {
mysql_hdr _a;
assert(datalength >= progress + sizeof(mysql_hdr)); // FIXME: this is a too optimistic assumption
memcpy(&_a,_ptr+progress,sizeof(mysql_hdr));
CompPktIN.pkt.size=_a.pkt_length+sizeof(mysql_hdr);
CompPktIN.pkt.ptr=(unsigned char *)l_alloc(CompPktIN.pkt.size);
if ((datalength-progress) >= CompPktIN.pkt.size) {
// we can copy the whole packet
memcpy(CompPktIN.pkt.ptr, _ptr+progress, CompPktIN.pkt.size);
CompPktIN.partial=0; // stays 0
progress+=CompPktIN.pkt.size;
PSarrayIN->add(CompPktIN.pkt.ptr, CompPktIN.pkt.size);
CompPktIN.pkt.ptr=NULL; // sanity
} else {
// not enough data for the whole packet
memcpy(CompPktIN.pkt.ptr, _ptr+progress, (datalength-progress));
CompPktIN.partial+=(datalength-progress);
progress=datalength; // we reached the end
}
} else {
if ((datalength-progress) >= (CompPktIN.pkt.size-CompPktIN.partial)) {
// we can copy till the end of the packet
memcpy((char *)CompPktIN.pkt.ptr + CompPktIN.partial , _ptr+progress, CompPktIN.pkt.size - CompPktIN.partial);
CompPktIN.partial=0;
progress+= CompPktIN.pkt.size - CompPktIN.partial;
PSarrayIN->add(CompPktIN.pkt.ptr, CompPktIN.pkt.size);
CompPktIN.pkt.ptr=NULL; // sanity
} else {
// not enough data for the whole packet
memcpy((char *)CompPktIN.pkt.ptr + CompPktIN.partial , _ptr+progress , (datalength-progress));
CompPktIN.partial+=(datalength-progress);
progress=datalength; // we reached the end
}
}
// mysql_hdr _a;
// memcpy(&_a,_ptr+progress,sizeof(mysql_hdr));
// unsigned int size=_a.pkt_length+sizeof(mysql_hdr);
// unsigned char *ptrP=(unsigned char *)l_alloc(size);
// memcpy(ptrP,_ptr+progress,size);
// progress+=size;
// PSarrayIN->add(ptrP,size);
}
if (payload_length) {
l_free(destLen,dest);
}
l_free(queueIN.pkt.size,queueIN.pkt.ptr);
pkts_recv++;
queueIN.pkt.size=0;
queueIN.pkt.ptr=NULL;
} else {
PSarrayIN->add(queueIN.pkt.ptr,queueIN.pkt.size);
pkts_recv++;
queueIN.pkt.size=0;
queueIN.pkt.ptr=NULL;
}
}
return ret;
}