Archive for the ‘Uncategorized’ Category.
February 25, 2015, 5:44 pm
Serving HTTPS content with golang is pretty straight forward. You’ll need to your certificate/key pem files to ListenAndServeTLS but that’s about it. However you may also want to insure that your users always use HTTPS in which case you can also listen on port 80 and just redirect them to the HTTPS site using RedirectHandler. The example below shows how you might do this:
package main
import (
"net/http"
"net"
)
func main() {
http.Handle("/", http.FileServer(http.Dir(".")))
go func() {
err := http.ListenAndServe(":80", http.RedirectHandler("https://mywebsite.com", http.StatusFound))
if err != nil {
panic("Error: " + err.Error())
}
}()
err := http.ListenAndServeTLS(":443", "cert.pem", "key.pem", nil)
if err != nil {
panic("Error: " + err.Error())
}
}
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())
}
}
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.")
}
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:
g++ rx.cpp -luhd -o rx
#include <uhd/types/tune_request.hpp>
#include <uhd/utils/thread_priority.hpp>
#include <uhd/utils/safe_main.hpp>
#include <uhd/usrp/multi_usrp.hpp>
#include <uhd/exception.hpp>
#include <iostream>
#include <fstream>
#include <csignal>
#include <complex>
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(""));
usrp->set_clock_source("internal"); // set clock
//always select the subdevice first, the channel mapping affects the other settings
usrp->set_rx_subdev_spec(string("A:A"));
std::cout << "Using Device: " << usrp->get_pp_string() << std::endl;
double rate = 1000000; // trying 1MSPS
usrp->set_rx_rate(rate);
//set the center frequency
double freq=0;
uhd::tune_request_t tune_request(freq);
usrp->set_rx_freq(tune_request);
//usrp->set_rx_gain(5);
//usrp->set_rx_bandwidth(100);
// ant = "";
// usrp->set_rx_antenna(ant);
// cout << usrp->get_mboard_sensor("lo_locked", 0).to_bool() << endl;
sleep(1);
/////////////// RECEIVE CODE
//create a receive streamer
uhd::stream_args_t stream_args("sc16","");
uhd::rx_streamer::sptr rx_stream = usrp->get_rx_stream(stream_args);
uhd::rx_metadata_t md;
std::vector<std::complex<short> > 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->issue_stream_cmd(stream_cmd);
for(;;) {
size_t num_rx_samps = rx_stream->recv(&buffer.front(), buffer.size(), md, 3.0, false);
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_TIMEOUT) { cerr << "timeout" << endl; }
if (md.error_code == uhd::rx_metadata_t::ERROR_CODE_OVERFLOW){ cerr << "overflow" << endl; }
if (md.error_code != uhd::rx_metadata_t::ERROR_CODE_NONE) { cerr << md.strerror() << endl; }
cout << "data size: " << num_rx_samps << " first: " << (&buffer.front())[0] << endl;
}
// Will never get here
stream_cmd.stream_mode = uhd::stream_cmd_t::STREAM_MODE_STOP_CONTINUOUS;
rx_stream->issue_stream_cmd(stream_cmd);
}
RSS