41J Blog

Archive for the ‘Uncategorized’ Category.

Serving gziped connect via HTTP in golang

February 24, 2015, 5:39 pm

The builtin HTTP server in the golang standard library does not serve gziped content. However you can relatively easily add a wrapper function to compress data on the fly. The best tool to do this appears to be go.httpgzip. A basic example of its usage might look like this:

import (
  "github.com/daaku/go.httpgzip"
  "net/http"
)
 
func main() {
  http.Handle("/", httpgzip.NewHandler(http.FileServer(http.Dir("."))))
  err := http.ListenAndServe(":80", nil)
  if err != nil {
    panic("Error: " + err.Error())
  }
}

Category: Uncategorized | Comment

Connect via a SOCKS server in golang

February 23, 2015, 5:39 pm

The function below allows you to setup a SOCKS connection in golang. You should already have connected to the SOCKS server using net.Dial. The function will then send the required header to connect to the target address/port provides in address:port format. For example:

conn, err = net.Dial("tcp", "socksproxy:8080")
err = socks_connect(conn, "hosttoconnectto:80")

You can then communicate with the target server via the SOCKS proxy.

func socks_connect(conn net.Conn, address string) (error) {
 
        host, portstr, err := net.SplitHostPort(address)
        port, err2 := strconv.Atoi(portstr)
        if err2 != nil {
          return errors.New("Unable to parse port")
        }
 
        version := []byte{0x04} // socks version 4
        cmd := []byte{0x01}     // socks stream mode
        buffer := bytes.NewBuffer([]byte{})
        binary.Write(buffer, binary.BigEndian, version)
        binary.Write(buffer, binary.BigEndian, cmd)
        binary.Write(buffer, binary.BigEndian, uint16(port))
        binary.Write(buffer, binary.BigEndian, []byte{0x00, 0x00, 0x00, 0x01})
        binary.Write(buffer, binary.BigEndian, []byte{0x00})
        binary.Write(buffer, binary.BigEndian, []byte(host))
        binary.Write(buffer, binary.BigEndian, []byte{0x00})
        binary.Write(conn, binary.BigEndian, buffer.Bytes())
 
        data := make([]byte, 8) // socks responses are 8 bytes
        count, err := conn.Read(data)
 
        if err != nil {
          return errors.New("Unable to connect to socks server.")
        }
        if count == 0 {
          return errors.New("Unable to connect to socks server.")
        }
        if data[1] == 0x5a { // success
                return nil
        }
 
        return errors.New("Unable to connect to socks server.")
}

Category: Uncategorized | Comment

USRP1 simple data capture in C++ example (UHD)

February 19, 2015, 4:46 pm

The code below streams data using the UHD at 1MSPS. It just prints the first 2 datapoints to the screen but can be used as the basis for other stuff. It’s also worth checking out rx_samples_to_file.cpp in the UHD source, but this example removes a lot of the cruft. Can be compiled with:

1	`g++ rx.cpp -luhd -o rx`

#include &lt;uhd/types/tune_request.hpp&gt;
#include &lt;uhd/utils/thread_priority.hpp&gt;
#include &lt;uhd/utils/safe_main.hpp&gt;
#include &lt;uhd/usrp/multi_usrp.hpp&gt;
#include &lt;uhd/exception.hpp&gt;
#include &lt;iostream&gt;
#include &lt;fstream&gt;
#include &lt;csignal&gt;
#include &lt;complex&gt;
 
using namespace std;
 
int UHD_SAFE_MAIN(int argc, char *argv[]){
    uhd::set_thread_priority_safe();
 
    uhd::usrp::multi_usrp::sptr usrp = uhd::usrp::multi_usrp::make(string(&quot;&quot;));
 
    usrp-&gt;set_clock_source(&quot;internal&quot;); // set clock
 
    //always select the subdevice first, the channel mapping affects the other settings
    usrp-&gt;set_rx_subdev_spec(string(&quot;A:A&quot;));
 
    std::cout &lt;&lt; &quot;Using Device: &quot; &lt;&lt; usrp-&gt;get_pp_string() &lt;&lt; std::endl;
    double rate = 1000000; // trying 1MSPS
    usrp-&gt;set_rx_rate(rate);
 
    //set the center frequency
    double freq=0;
    uhd::tune_request_t tune_request(freq);
    usrp-&gt;set_rx_freq(tune_request);
 
    //usrp-&gt;set_rx_gain(5);
    //usrp-&gt;set_rx_bandwidth(100);
 
//    ant = &quot;&quot;;
//    usrp-&gt;set_rx_antenna(ant);
 
//   cout &lt;&lt; usrp-&gt;get_mboard_sensor(&quot;lo_locked&quot;, 0).to_bool() &lt;&lt; endl;
 
    sleep(1);
 
/////////////// RECEIVE CODE
 
    //create a receive streamer
    uhd::stream_args_t stream_args(&quot;sc16&quot;,&quot;&quot;);
    uhd::rx_streamer::sptr rx_stream = usrp-&gt;get_rx_stream(stream_args);
 
    uhd::rx_metadata_t md;
    std::vector&lt;std::complex&lt;short&gt; &gt; buffer(50000);
 
    //setup streaming
    uhd::stream_cmd_t stream_cmd(uhd::stream_cmd_t::STREAM_MODE_START_CONTINUOUS);
    stream_cmd.num_samps = 0;
    stream_cmd.stream_now = true;
    stream_cmd.time_spec = uhd::time_spec_t();
    rx_stream-&gt;issue_stream_cmd(stream_cmd);
 
    for(;;) {
 
        size_t num_rx_samps = rx_stream-&gt;recv(&amp;buffer.front(), buffer.size(), md, 3.0, false);
 
        if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { cerr &lt;&lt; &quot;timeout&quot;  &lt;&lt; endl; }
        if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW){ cerr &lt;&lt; &quot;overflow&quot; &lt;&lt; endl; }
        if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE)    { cerr &lt;&lt;  md.strerror() &lt;&lt; endl; }
 
        cout &lt;&lt; &quot;data size: &quot; &lt;&lt; num_rx_samps &lt;&lt; &quot; first: &quot; &lt;&lt; (&amp;buffer.front())[0] &lt;&lt; endl;
    }
 
    // Will never get here
    stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
    rx_stream-&gt;issue_stream_cmd(stream_cmd);
}

Category: Uncategorized | Comment

ESP8266 – esp1 PCB scans

January 29, 2015, 1:14 am

There are some partial layout images for the esp1 but they seem incomplete. I wanted to make sure I knew exactly what was going on with this layout and as they’re so cheap decided to pull the components off a board and scan it. Actually a little pointless, as I was wondering if there was a trace snaking under the chip, but nope! Anyway, for reference, here are the scan images: