Anmol Sarma

A DIY USB Mouse Jiggler

Sun, 21 Jun 2020 21:24:50 +0530

The Great Pandemic Lockdown of 2020 forced companies to adopt remote work. With no existing provisions for WFH, bizarre ad-hoc setups emerged. A case in point, my roommate was issued two laptops: One for development and a second locked down machine to connect to production servers. The second laptop was configured with a very aggressive lock screen timeout with no way to change or disable it. This made keeping an eye on prod rather annoying.

One way to prevent Windows from locking the screen is by simulating user activity: say moving the mouse. This would have been trivial to accomplish in software if it wasn’t for the administrative policy restricting which applications could be run.

This seems to be a common enough occurrence in corporate environments that there are companies that sell purpose-built hardware to mitigate the situation. Basically, these devices pretend to be a USB mouse or keyboard and periodically send random mouse events or keystrokes to the connected host computer. Getting hold of one of these seems unlikely in the current situation. Building one was the only option. Fortunately, I had a Stellaris Launchpad lying around, (literally) gathering dust that was perfect for this.

The board has a USB capable ARM Cortex microcontroller onboard and can be used with a USB stack that TI provides royalty-free. All I had to do was to figure out how to configure the USB stack to emulate a USB HID mouse. The documentation refers to a usb_dev_mouse example application but I for one was unable to find it in the TivaWare package. The TivaWare USB Library is fairly straightforward to use. Apart from the minimal boiler-plate, it is almost as simple as Arduino’s Mouse library. Coupled with the Driverlib HAL to configure the timer, I was able to get a mouse jiggler working in short order. The USB string descriptors took up more lines of code than the actual application:

void
timerISR (void)
{
  // Clear the timer interrupt source to avoid being triggered again 
  // immediately on exit
  TimerIntClear (TIMER0_BASE, TIMER_TIMA_TIMEOUT);
  // Disable interrupts so we can get some work done
  IntMasterDisable ();

  // Move the cursor by a pixel along each axis in a random direction
  int8_t x = (rand () & 1) ? 1 : -1;
  int8_t y = (rand () & 1) ? 1 : -1;
  USBDHIDMouseStateChange ((void *) &g_jiggler, x, y, 0);

  IntMasterEnable ();

}

int
main (void)
{

  // Configure the clock to directly run from the crysal oscillator
  SysCtlClockSet (SYSCTL_SYSDIV_1 | SYSCTL_USE_OSC | SYSCTL_OSC_MAIN |
                  SYSCTL_XTAL_16MHZ);

  SysCtlPeripheralEnable (SYSCTL_PERIPH_TIMER0);

  // Enable the USB peripheral 
  SysCtlPeripheralEnable (SYSCTL_PERIPH_GPIOD);
  GPIOPinTypeUSBAnalog (GPIO_PORTD_BASE, GPIO_PIN_4 | GPIO_PIN_5);

  // Configure the Timer to fire every 30 seconds
  TimerConfigure (TIMER0_BASE, TIMER_CFG_PERIODIC);
  TimerLoadSet (TIMER0_BASE, TIMER_A, SysCtlClockGet () * 30);

  IntEnable (INT_TIMER0A);
  TimerIntEnable (TIMER0_BASE, TIMER_TIMA_TIMEOUT);
  TimerEnable (TIMER0_BASE, TIMER_A);

  USBStackModeSet (0, USB_MODE_DEVICE, 0);
  // Initialize the USB controller and attach the mouse jiggler
  // device to the USB bus
  USBDHIDMouseInit (0, (tUSBDHIDMouseDevice *) &g_jiggler );

  // Enable processor interrupts
  IntMasterEnable ();

  while (1);

}

So, with the jiggler attached and the laptop hooked up to a TV screen, my roommate can monitor prod and continue to lose sleep in peace.

File Creation Time in Linux

Sun, 23 Jun 2019 19:24:22 +0530

The stat utility can be used to retrieve the Unix file timestamps namely atime, ctime and mtime. Of these, the benefit of mtime which records the last time when the file was modified is immediately apparent. On the other hand, atime¹ which records the last time the file was accessed has been called “perhaps the most stupid Unix design idea of all times”. Intuitively, one might expect ctime to record the creation time of a file. However, ctime records the last time when the metadata of a file was changed.

Typically, Unices do not record file creation times. While some individual filesystems do record file creation times², until recently Linux lacked a common interface to actually expose them to userspace applications. As a result, the output of stat (GNU coreutils v8.30) on an ext4 filesystem (Which does record creation times) looks something like this:

$ stat .
  File: .
  Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 803h/2051d      Inode: 3588416     Links: 18
Access: (0775/drwxrwxr-x)  Uid: ( 1000/ anmol)   Gid: ( 1000/ anmol)
Access: 2019-06-23 10:49:04.056933574 +0000
Modify: 2019-05-19 13:29:59.609167627 +0000
Change: 2019-05-19 13:29:59.609167627 +0000
 Birth: -

With the “Birth” field, meant to show the creation time, sporting a depressing “-”.

The fact that ctime does not mean creation time but change time coupled with the absence of a real creation time interface does lead to quite a bit of confusion. The confusion seems so pervasive that the msdos driver in the Linux kernel happily clobbers the FAT creation time with the Unix change time!

The limitations of the current stat() system call have been known for some time. A new system call providing extended attributes was first proposed in 2010 with the new statx() interface finally being merged into Linux 4.11 in 2017. It took so long at least in part because kernel developers quickly ran into one of the hardest problems in Computer Science: naming things. Because there was no standard to guide them, each filesystem took to calling creation time by a different name. Ext4 and XFS called it crtime while Btrfs and JFS called it otime. Implementations also have slightly different semantics with JFS storing creation time only with the precision of seconds.

Glibc took a while to add a wrapper for statx() with support landing in version 2.28 which was released in 2018. Fast forward to March 2019 when GNU coreutils 8.31 was released with stat finally gaining support for reading the file creation time:

$ stat .
  File: .
  Size: 4096            Blocks: 8          IO Block: 4096   directory
Device: 803h/2051d      Inode: 3588416     Links: 18
Access: (0775/drwxrwxr-x)  Uid: ( 1000/ anmol)   Gid: ( 1000/ anmol)
Access: 2019-06-23 10:49:04.056933574 +0000
Modify: 2019-05-19 13:29:59.609167627 +0000
Change: 2019-05-19 13:29:59.609167627 +0000
 Birth: 2019-05-19 13:13:50.100925514 +0000

The impact of atime on disk performance is mitigated by the use of relatime on modern Linux systems. ↩︎
For ext4, one can get the crtime of a file using the stat subcommand of the confusingly named debugfs utility. ↩︎

Talk @ Netdev 0x13: Improved System Call Batching for Network I/O

Sun, 26 May 2019 21:07:27 +0530

My colleagues Rahul Jadhav, Zhen Cao and me had our talk for Netdev 0x13 accepted. Our basic idea is reducing the CPU cycles consumed by amortizing the system call overhead of network I/O operations.

At the time we started our work, io_uring was not yet a thing. With the benefit of hindsight however, it is clear that io_uring is the way forward.

Here’s the video of Rahul delivering the talk:

And the slides:

Books I Read in 2018

Sun, 12 May 2019 23:41:22 +0530

The Information: A History, a Theory, a Flood by James Gleick

Eclectic, engrossing and thoroughly enjoyable. From Ada Lovelace and Charles Babbage to Maxwell and Einstein to Shanon and Turing: Gleick’s masterful prose captures both the ideas and personalities of the men and women who made the world what it is today. Apart from the lucid explanation of the foundations of information theory, the book is packed full of fascinating historical accounts. To top it off is the brilliant synthesis and narrative. Would highly recommend.

The White Tiger by Aravind Adiga

A parable new India relating individuality’s struggle for freedom from the societal forces of class and caste that seek to imprison it. The narrative while being deeply allegorical is at the same time raw, visceral and credulous. Devoid of any idealistic or ideological pretensions, the story of Balram Halwai’s rise paints a wholly unflattering yet undeniably accurate picture of modern India. Would highly recommend.

Masters of Doom by David Kushner

A gushing homage from a DOOM fanboy meant for other video game fanboys. While the detailed technical discussions of early games are interesting, the book’s focus is on the behind the scenes drama between John Carmack and John Romero. An inordinate amount of prose is spent on trite character profiles which makes parts of the book an absolute chore to read. Would not recommend.

Artemis by Andy Weir

Like The Martian but on the moon and with added criminal intrigue. The action-packed plot is complemented by charming and extremely likeable characters. While the science is solid the writing is anything but. The mostly unambitious dialogue turns wince-inducing in places. Overall, a quick and enjoyable read. Would recommend.

An Era of Darkness by Shashi Tharoor

Based on Tharoor’s virally popular Oxford Union debate, An Era of Darkness is a breathless polemic about the horrors of British rule in India. While the book does not offer anything new – something that the preface readily admits, it does offer a cogent rebuttal to revived colonial apologism. The work is assuredly nationalistic, not of a narrow, parochial or exclusionary sort but of the staunchly liberal, self-assured and inclusive variety. That being said, the book does feel a bit longer than necessary. Would recommend.

The Girl with the Dragon Tattoo by Stieg Larsson as translated by Reg Keeland

A slightly atypical murder mystery potboiler. The storyline while not entirely bad is chock full of genre cliches and the translated prose isn’t exactly exciting. The drawn-out novel is only redeemed by the character of Lisbeth Salander, the eponymous girl with the dragon tattoo. An entertaining read but not a particularly memorable one. Would recommend.

Flash Boys by Michael Lewis

Part misguided hit piece on High Frequency Trading, part hagiography of Brad Katsuyama and part native advertisement for the IEX stock exchange: Flash Boys is utterly without merit. Michel Lewis valiantly tries to project large institutional investors as heroic victims while repeatedly making the absurd claim that the markets are rigged. Even putting the bias aside, the book could be cut down to a long-form article while conveying exactly the same amount of information. Would not recommend.

Flowers for Algernon by Daniel Keyes

A heart-wrenching science fiction tale that confronts the accepted notions of intelligence, humanity, love and kindness. Written as a series of progress reports by the protagonist Charlie Gordon as he experiences the full cycle of effects of an experimental cognitive enhancement operation. The journey is captivating and ultimately heartbreaking. Would highly recommend.

Surely You’re Joking, Mr. Feynman! by Richard Feynman

A collection of anecdotes and reminisces from the life of Richard Feynmanmann. While on the whole very amusing, the tone of the stories tends to be rather self-congratulatory with some episodes definitely stretching credulity. But it is a worthy read with the very last chapter, Cargo Cult Science deserving a special mention. Would recommend.

The Old Man and the Sea by Ernest Hemingway

True to its name almost the entirety of the novel is an account of a conspicuously unlucky old man and his struggle with the sea and its creatures. While it is over-romanticized to the point of unrealism, Hemmingway manages to capture the majestic force of nature, the raw physicality of a fisherman’s life and above all the indomitable force of the human spirit. Would recommend.

Countdown to Zero Day by Kim Zetter

A thoroughly journalistic account of the Stuxnet worm. Tightly written and technically sound, it focusses mostly on the heroic efforts of security researchers who discovered and reverse engineered the worm. The technical exposition is lucid with just the right amount of detail. No liberties are taken with mundane facts to craft a biased or misleading narrative. The geopolitics and circumstances surrounding Stuxnet too are dealt from a neutral perspective without the speculative hysteria that seems to permeate most cybersecurity reporting. Would highly recommend.

The Ministry of Utmost Happiness by Arundhati Roy

A somewhat underwhelming comeback novel from Arundhati Roy after a gap of more than two decades. The sprawling plot line is unfolded mostly by telling and not by showing. And while Roy can effortlessly make the reader look where she wants, it’s not entirely clear as to what she wants us to see. In the hands of a lesser writer, such faults would have spelt doom but in Roy more than redeems the novel with her masterful prose. However, the perspective in some places is confusing and politics are inserted into the narrative with all the subtlety of a sledgehammer. While it’s no God of Small Things, it makes for a decent read. Would recommend.

Factfulness by Hans Rosling, Ola Rosling and Anna Rosling Rönnlund

Combating outdated perceptions, misleading generalizations and meaningless labels in the search for truth, Factfulness is hands down the best book I’ve read in 2018. Measuredly staying away from hysteria, Factfulness makes the case that not only is the world becoming a better place but also that the threat of overpopulation is overblown. The book provides a framework for better understanding of the world and offers specific advice on how to avoid being misled by information. Would highly recommend.

Dune by Frank Herbert

An undeniable classic of science fiction, Dune at its surface is about an interplanetary blood feud. But beyond the seemingly trite premise is a vivid account of a weird and wonderful world with a very unique zoology. The world building with its myriad cultures is absolutely stellar, the political intrigue is captivating and the character dynamics are powerfully evocative. The only weakness of the novel is the tendency to use long winding speeches to explain the plot points. Would recommend.

Bad Blood by John Carreyrou

The riveting tale of the spectacular rise and epic fall of Silicon Valley’s Blood Unicorn. A behind-the-scenes account of how John Carreyrou’s explosive pieces in the Wall Street Journal came to be, Bad Blood combines journalistic prowess with narrative flair. The lurid details of the puffery, duplicity and manipulation behind Theranos’s eye-watering valuation make for a satisfying sense of schadenfreude. Would recommend.

Sacred Games by Vikram Chandra

A story about a washed up gangster, a cynical cop and the city of Mumbai in peril. The main plot flows at a meandering pace while drawing in a staggering number of tributaries. And frankly, the tributaries are far more interesting. The sense of impending doom never really hits home and everything is a bit too well done. Too much time is spent on the protagonist’s backstory which is entirely uninteresting. The dialogue while interlaced with vernacular vocabulary simply does not carry any emotional force. At over 700 pages, the book just isn’t worth the effort. The Netflix show, while significantly different from the source material, is a much better proposition. Would not recommend.

Born a Crime by Trevor Noah

A collection of stories from Trever Noah’s youth while growing up in of post-Apartheid South Africa. Yhe book is not meant to be a comprehensive treatise of that tumultuous period but a personal account of how it was to live through it all. The writing is both insightful and extremely humorous. Naturally, it deals with issues of racism, poverty and crime: But despite its heavy subject matter, it is a very pleasant read. Would recommend.

Tinker Tailor Soldier Spy by John le Carré

A dense novel with a convoluted plot and way too many named characters making cameos. The pacing is unsettlingly uneven and there are no sympathetic characters. The supposedly accurate jargon-laced description of spycraft makes for extremely dull reading. Would not recommend.

Red Plenty by Francis Spufford

The Soviet Union was founded on a dream. The talk about establishing the dictatorship of the proletariat was mostly bluster. The real dream was optimizing production by means of central planning. Such a system, it was presumed would avoid the inherent inefficiencies of the market. Red Plenty is a genre-bending collection of vivid short stories that capture life under such a planned economy in all its triumphs and absurdities. While none of the stories is true, the details that back them are all very much real. Would highly recommend.

The Colour of Magic by Terry Pratchett

An absurdist fantasy featuring an incompetent wizard. While the book definitely has its moments of brilliant humour, they feel few and far between. The world and the characters have a lot of potential which I am told is realized to full effect in the later Discworld novels. Sadly, in The Color of Magic though, Terry Prachet is yet to find his voice. Would not recommend.

Thinking, Fast and Slow by Daniel Kahneman

Really should have been subtitled The Ludic Fallacy Run Amok. A collection of studies and anecdotal stories all around a central theme, suitably vulgarized for general consumption. Filled with grand generalisations based on dubious conclusions from small under-powered behavioural experiments. Much ado is made about the so-called Priming Effect which has since been thoroughly been debunked. The central premise of there being two distinct modes of thinking is asserted with no evidence. One this the book does prove is that behavioural economics –that bastard child of psychology – is built on an edifice of fashionable nonsense. Would not recommend.

The Handmaid’s Tale by Margaret Atwood

A speculative dystopian novel set in a deeply patriarchal world taken over by religious fundamentalists. The protagonist is a woman called ‘Offred’, her name signifying her status as a possession ‘of Fred’. Extremely well written, the book features a double narrative, with one chronicling the fall of the old order and the other dealing with life under the new. The intimate prose and visceral detail make reading The Handmaid’s Tale an almost physical experience. Would highly recommend.

Man’s Search for Meaning by Viktor Frankl

Literal survivorship bias taken to the absolute extreme. Frankl devises an entire theory of psychotherapy backed by the fact that he survived a concentration camp when so many others perished. The narrative deceptively suggests that Frankl spent months in the Auschwitz death camp when in reality he spent most of his time as a prisoner in the Dachau labour camp. Also conveniently left out are details about Frankl’s unqualified experiments with lobotomy on his fellow prisoners. Would not recommend.

Em and the Big Hoom by Jerry Pinto

A moving tragicomic family drama centred around the bipolar manic-depressive mother Em. The story feels too authentic to not be true. While it does not intend to be a commentary on the state of mental health care in India, the parts that deal with it are heartbreaking. Despite the melancholy setting, the dialogue is equal parts brilliant and funny. Would recommend.

The Inner Game of Tennis by Timothy Gallwey

At 161 pages it might seem short but is in fact 160 pages too long. It boldly claims its advice isn’t applicable just to tennis but to all endeavours of life. While I can’t speak about its applicability to tennis, I did not find absolutely anything of value in the book which for the most part is trite and repetitive. Would not recommend.

Lord of the Flies by William Golding

On its surface, a Robinsonade featuring a group of schoolboys. But on a deeper level an allegorical commentary on civilization, the basis of cooperation and the memetic power of belief. While the premise is compelling enough, the characters are not particularly well developed, with each of them neatly fitting into an archetype for plot convenience. Would recommend.

The Road to Wigan Pier by George Orwell

A Sociological investigation leading to an impassioned polemic. The first part is made up of Orwell’s journalistic reportage from his journey through the depressed areas of North England in the midst of the Great Depression. From the lives of miners to housing shortages to the sheer ugliness of industrial towns, Orwell’s writing is detailed, vivid and ultimately deeply disturbing. The second has Orwell playing the devil’s advocate pointing out the hypocrisies, pettiness and crankiness exhibited by self-avowed Socialists of the champagne drinking variety. Would recommend.

Poonachi: Or the Story of a Black Goat by Perumal Murugan as translated by N Kalyan Raman

A brilliant political commentary dressed-up as a fable about a black goat. The story masterfully captures the trials and tribulations of life in an Indian village. Rich in allegory, Perumal Murugan captures the rebelliousness of the proletarian spirit. The spirit, however, is broken by the material deprivation and authoritarian subjugation that serve as the backdrop for a story that is fundamentally about love and tenderness. Would recommend.

Why We Sleep by Matthew Walker

A scholarly explanation of Why We Sleep and an impassioned plea for Why We Should Be Sleeping A Lot More Than We Currently Do. Be it improving cognitive performance, physical endurance, attractiveness or general well being, Dr Walker’s scientific remedy for everything is ensuring that one regularly gets 8 hours of sleep. He goes so far as to say that there is no human physiological process that is not improved by sufficient sleep. The book has more potential to be life changing that any self-help book out there, provided the sound advice is actually adhered to. The pithy takeaway being: Sacrificing sleep does not make you hardworking or successful, it makes you fat and stupid. Would highly recommend.

Ghachar Ghochar by Vivek Shanbhag as translated by Srinath Perur

A psychological drama about a dysfunctional family that is tangled up beyond repair. While the philosophical musings of the narrator make for amusing reading, the crux of the novel is the sequence of seemingly meaningless events and actions which capture the characters’ state of mind. There isn’t a larger overarching theme apart from the possibility of money complicating and changing the dynamics of human relationships. The novel is more of an exploration rather than an explanation. Would recommend.

Network Redirections in Bash

Sat, 04 May 2019 20:59:15 +0530

A few months ago, while reading the man page for recvmmsg(), I came across this snippet:

$ while true; do echo $RANDOM > /dev/udp/127.0.0.1/1234;
     sleep 0.25; done

And as advertised, it sends a UDP datagram containing a random number to port 1234 every 250 ms. I didn’t recall ever seeing a /dev/udp and so was a bit surprised that it worked. And as it happens, ls was not able to access the file that I had just written to:

ls: cannot access '/dev/udp/127.0.0.1/1234': No such file or directory

Puzzled and intrigued, I echoed Foo Bar Baz to /dev/udp/127.0.0.1/1337 and reached for strace:

...
2423 socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP) = 4
12423 connect(4, {sa_family=AF_INET, sin_port=htons(1337), sin_addr=inet_addr("127.0.0.1")}, 16) = 0
12423 fcntl(1, F_GETFD)                 = 0
12423 fcntl(1, F_DUPFD, 10)             = 10
12423 fcntl(1, F_GETFD)                 = 0
12423 fcntl(10, F_SETFD, FD_CLOEXEC)    = 0
12423 dup2(4, 1)                        = 1
12423 close(4)                          = 0
12423 fstat(1, {st_mode=S_IFSOCK|0777, st_size=0, ...}) = 0
12423 write(1, "Foo Bar Baz\n", 12)     = 12
...

Seemingly, a normal UDP socket was being created and written to using the regular sycall interface. That refuted my initial suspicion that some kind of a special file backed by the kernel was involved. But who was actually creating the socket?

A peek at Bash’s code answered that question:

redir.c:

/* A list of pattern/value pairs for filenames that the redirection
   code handles specially. */
static STRING_INT_ALIST _redir_special_filenames[] = {
#if !defined (HAVE_DEV_FD)
  { "/dev/fd/[0-9]*", RF_DEVFD },
#endif
#if !defined (HAVE_DEV_STDIN)
  { "/dev/stderr", RF_DEVSTDERR },
  { "/dev/stdin", RF_DEVSTDIN },
  { "/dev/stdout", RF_DEVSTDOUT },
#endif
#if defined (NETWORK_REDIRECTIONS)
  { "/dev/tcp/*/*", RF_DEVTCP },
  { "/dev/udp/*/*", RF_DEVUDP },
#endif
  { (char *)NULL, -1 }
};

So, redirection involving /dev/udp/ is handled specially by Bash¹ and it uses BSD Sockets API to create a socket:

lib/sh/netopen.c:

/*
 * Open a TCP or UDP connection to HOST on port SERV.  Uses the
 * traditional BSD mechanisms.  Returns the connected socket or -1 on error.
 */
static int
_netopen4(host, serv, typ)
     char *host, *serv;
     int typ;
{
  struct in_addr ina;
  struct sockaddr_in sin;
  unsigned short p;
  int s, e;

  if (_getaddr(host, &ina) == 0)
    {
      internal_error (_("%s: host unknown"), host);
      errno = EINVAL;
      return -1;
    }

  if (_getserv(serv, typ, &p) == 0)
    {
      internal_error(_("%s: invalid service"), serv);
      errno = EINVAL;
      return -1;
    }

  memset ((char *)&sin, 0, sizeof(sin));
  sin.sin_family = AF_INET;
  sin.sin_port = p;
  sin.sin_addr = ina;

  s = socket(AF_INET, (typ == 't') ? SOCK_STREAM : SOCK_DGRAM, 0);
  if (s < 0)
    {
      sys_error ("socket");
      return (-1);
    }

  if (connect (s, (struct sockaddr *)&sin, sizeof (sin)) < 0)
    {
      e = errno;
      sys_error("connect");
      close(s);
      errno = e;
      return (-1);
    }

  return(s);
}

Which means we can actually make HTTP requests using Bash:

exec 3<> /dev/tcp/checkip.amazonaws.com/80
printf "GET / HTTP/1.1\r\nHost: checkip.amazonaws.com\r\nConnection: close\r\n\r\n" >&3
tail -n1 <&3

No curl needed! /jk

Apart from Bash, in the versions and configurations packaged in Ubuntu 18.04, only ksh supports network redirections – ash, csh, dash, fish, and zsh do not.

I don’t think I will actually have any use for network redirections but this was a fun little rabbit hole to dive into.

NOTE: Code snippets from Bash are licensed under GPLv3, the snippet from the man page is licensed differently

At least on Linux, the other special patterns handled by bash like /dev/fd and /dev/stdint actually are special files backed by the kernel. The Bash manual notes that it may emulate them internally on platforms that do not support them. ↩︎

Stop Memsetting Structures

Sat, 27 Apr 2019 23:59:42 +0530

TL;DR: Use C99’s designated initializers instead. Because it’s 2019!

Edit: This post was discussed on Hacker News, Lobste.rs and /r/c_programming. It has been updated to address some of the concerns raised by commenters.

One of the little things that annoy me when reading code is the unnecessary use of memset() to zero-out a struct. Something I see frequently in networking code that uses the BSD sockets API.

Consider this snippet of code from the venerable Beej’s Guide to Network Programming:

struct addrinfo hints;
...

memset(&hints, 0, sizeof hints);
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_STREAM;
hints.ai_flags = AI_PASSIVE; // use my IP

So, we first declare a struct, memset it to zero and then initialize the fields we are interested in. This is all fine except for the fact that the same result can be achieved with the following:

struct addrinfo hints = {
	.ai_family = AF_UNSPEC,
	.ai_socktype = SOCK_STREAM,
	.ai_flags = AI_PASSIVE // use my IP
};

Which in my humble and very subjective opinion looks much cleaner.

The second version uses a feature standardized in C99 called designated initializers. This allows initializing elements of an aggregate type in any order by specifying the array indices or structure field names. Elements that are not specified are initialized as if they are static objects: arithmetic types are initialized to 0; pointers are initialized to NULL. This is also presumably less expensive than a memset() as it avoids clearing memory that will be assigned to.

If the structure has padding, using designated initializers will not initialize it to zero. This is not usually a problem. However, this may inadvertently lead to information leaks when passing a structure from a more privileged context to a less privileged one: Like when passing memory from the kernel back to userspace.

Now to be fair to Beej, he first wrote The Guide in 1995. But if you’re writing new code in 2019, there is really no reason to not use designated initializers¹. Except to specifically avoid memory disclosures. Cue the Rust Evangelism Strike Force chiming in to say that there is really no reason to be writing new C code in 2019.

While we’re on the topic of little annoyances, another pattern I often see is using a variable just to pass what is effectively a literal to setsockopt():

int yes=1;
setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof (yes)) ;

Which can instead be written as:

setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &(int) {1}, sizeof(int));

This uses yet another C99 feature called compound literals. If the magic 1 value bothers you, you can always:

setsockopt(listener, SOL_SOCKET, SO_REUSEADDR, &(int) {true}, sizeof(int));

And finally, there is absolutely no reason to check if a pointer is NULL just before calling free() on it:

if(NULL != ptr)
	free(ptr);

Quoting the standard Section 7.20.3.2 (p. 313): If ptr is a null pointer, no action occurs. If a system deviates from this expectation, it is clearly evil. It is advised to Kill It With Fire.

If you were relying on memcmp() to compare structs, that will probably no longer work. But you knew what you were getting yourself into, didn’t you? ↩︎

Single-stepping through the Kernel

Sun, 03 Feb 2019 18:57:45 +0530

There may come a time in a system programmer’s life when she needs to leave the civilized safety of the userland and confront the unspeakable horrors that dwell in the depths of the Kernel space. While higher beings might pour scorn on the very idea of a Kernel debugger, us lesser mortals may have no other recourse but to single-step through Kernel code when the rivers begin to run dry. This guide will help you do just that. We hope you never actually have to.

Ominous sounding intro-bait notwithstanding, setting up a virtual machine for Kernel debugging isn’t really that difficult. It only needs a bit of preparation. If you just want a copypasta, skip to the end. If you’re interested in the predicaments involved and how to deal with them, read on.

N.B.: “But which kernel are you talking about?”, some heathens may invariably ask when it is obvious that Kernel with a capital K refers to the One True Kernel.

Building the Kernel

Using a minimal Kernel configuration instead of the kitchen-sink one that distributions usually ship will make life a lot easier. You will first need to grab the source code for the Kernel you are interested in. We will use the latest Kernel release tarball from kernel.org, which at the time of writing is 4.20.6. Inside the extracted source directory, invoke the following:

make defconfig
make kvmconfig
make -j4

This will build a minimal Kernel image that can be booted in QEMU like so:

qemu-system-x86_64 -kernel linux-4.20.6/arch/x86/boot/bzImage

This should bring up an ancient-looking window with a cryptic error message:

You could try pasting the error message into ~~Google~~ a search engine: Except for the fact that you can’t select the text in the window. And frankly, the window just looks annoying! So, ignoring the actual error for a moment, let’s try to get QEMU to print to the console instead of a spawning a new graphical window:

qemu-system-x86_64 -kernel -nographic linux-4.20.6/arch/x86/boot/bzImage

QEMU spits out a single line:

qemu-system-x86_64: warning: TCG doesn't support requested feature: CPUID.01H:ECX.vmx [bit 5]

Htop tells me QEMU is using 100% of a CPU and my laptop fan agrees. But there is no output whatsoever and Ctrl-c doesn’t work! What does work, however, is pressing Ctrl-a and then hitting x:

QEMU: Terminated

Turns out that by passing -nographic, we have plugged out QEMU’s virtual monitor. Now, to actually see any output, we need to tell the Kernel to write to a serial port:

qemu-system-x86_64 -nographic -kernel linux-4.20.6/arch/x86/boot/bzImage -append "console=ttyS0"

It worked! Now we can read error message in all its glory:

[    1.333008] VFS: Cannot open root device "(null)" or unknown-block(0,0): error -6
[    1.334024] Please append a correct "root=" boot option; here are the available partitions:
[    1.335152] 0b00         1048575 sr0 
[    1.335153]  driver: sr
[    1.335996] Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0)
[    1.337104] CPU: 0 PID: 1 Comm: swapper/0 Not tainted 4.20.6 #1
[    1.337901] Hardware name: QEMU Standard PC (i440FX + PIIX, 1996), BIOS 1.10.2-1ubuntu1 04/01/2014
[    1.339091] Call Trace:
[    1.339437]  dump_stack+0x46/0x5b
[    1.339888]  panic+0xf3/0x248
[    1.340295]  mount_block_root+0x184/0x248
[    1.340838]  ? set_debug_rodata+0xc/0xc
[    1.341357]  mount_root+0x121/0x13f
[    1.341837]  prepare_namespace+0x130/0x166
[    1.342378]  kernel_init_freeable+0x1ed/0x1ff
[    1.342965]  ? rest_init+0xb0/0xb0
[    1.343427]  kernel_init+0x5/0x100
[    1.343888]  ret_from_fork+0x35/0x40
[    1.344526] Kernel Offset: 0x1200000 from 0xffffffff81000000 (relocation range: 0xffffffff80000000-0xffffffffbfffffff)
[    1.345956] ---[ end Kernel panic - not syncing: VFS: Unable to mount root fs on unknown-block(0,0) ]---

So, the Kernel didn’t find a root filesystem to kick off the user mode and panicked. Lets fix that by creating a root filesystem image.

Creating a Root Filesystem

Start by creating an empty image:

qemu-img create rootfs.img 1G

And then format it as ext4 and mount it:

mkfs.ext4 rootfs.img
mkdir mnt
sudo mount -o loop rootfs.img mnt/

Now we can populate it using debootstrap:

sudo debootstrap bionic mnt/

This will create a root filesystem based on Ubuntu 18.04 Bionic Beaver. Of course, feel free to replace bionic with any release that you prefer.

And unmount the filesystem once we’re done. This is important if you want to avoid corrupted images!

sudo umount mnt

Now boot the Kernel with our filesystem. We need to tell QEMU to use our image as a virtual hard drive and we also need to tell the Kernel to use the hard drive as the root filesystem:

qemu-system-x86_64 -nographic -kernel linux-4.20.6/arch/x86/boot/bzImage -hda rootfs.img -append "root=/dev/sda console=ttyS0"

This time the Kernel shouldn’t panic and you should eventually see a login prompt. We could have setup a user while creating the filesystem but it’s annoying to have to login each time we boot up the VM. Let’s enable auto login as root instead.

Terminate QEMU (Ctrl-a, x), mount the filesystem image again and then create the configuration folder structure:

sudo mount -o loop rootfs.img mnt/
sudo mkdir -p mnt/etc/systemd/system/serial-getty@ttyS0.service.d

Add the following lines to mnt/etc/systemd/system/serial-getty@ttyS0.service.d/autologin.conf:

[Service]
ExecStart=
ExecStart=-/sbin/agetty --noissue --autologin root %I $TERM
Type=idle

Make sure to unmount the filesystem and then boot the Kernel again. This time you should be automatically logged in.

Gracefully shutdown the VM:

halt -p

Attaching a debugger

Let’s rebuild the Kernel with debugging symbols enabled:

./scripts/config -e CONFIG_DEBUG_INFO
make -j4

Now, boot the Kernel again, this time passing the -s flag which will make QEMU listen on TCP port 1234:

qemu-system-x86_64 -nographic -kernel linux-4.20.6/arch/x86/boot/bzImage -hda rootfs.img -append "root=/dev/sda console=ttyS0" -s

Now, in another terminal start gdb and attach to QEMU:

gdb ./linux-4.20.6/vmlinux 
...
Reading symbols from ./linux-4.20.6/vmlinux...done.
(gdb) target remote :1234
Remote debugging using :1234
0xffffffff95a2f8f4 in ?? ()
(gdb)

You can set a breakpoint on Kernel function, for instance do_sys_open():

(gdb) b do_sys_open 
Breakpoint 1 at 0xffffffff811b2720: file fs/open.c, line 1049.
(gdb) c
Continuing.

Now try opening a file in VM which should result in do_sys_open() getting invoked… And nothing happens?! The breakpoint in gdb is not hit. This due to a Kernel security feature called KASLR. KASLR can be disabled at boot time by adding nokaslr to the Kernel command line arguments. But, let’s actually rebuild the Kernel without KASLR. While we are at it, let’s also disable loadable module support as well which will save us the trouble of copying the modules to the filesystem.

./scripts/config -e CONFIG_DEBUG_INFO -d CONFIG_RANDOMIZE_BASE -d CONFIG_MODULES
make olddefconfig # Resolve dependencies
make -j4

Reboot the Kernel again, attach gdb, set a breakpoint on do_sys_open() and run cat /etc/issue in the guest. This time the breakpoint should be hit. But probably not where you expected:

Breakpoint 1, do_sys_open (dfd=-100, filename=0x7f96074ad428 "/etc/ld.so.cache", flags=557056, mode=0) at fs/open.c:1049
1049    {
(gdb) c
Continuing.

Breakpoint 1, do_sys_open (dfd=-100, filename=0x7f96076b5dd0 "/lib/x86_64-linux-gnu/libc.so.6", flags=557056, mode=0) at fs/open.c:1049
1049    {
(gdb) c
Continuing.

Breakpoint 1, do_sys_open (dfd=-100, filename=0x7ffe9e630e8e "/etc/issue", flags=32768, mode=0) at fs/open.c:1049
1049    {
(gdb)

Congratulations! From this point, you can single-step away to your heart’s content.

By default, the root filesystem is mounted read only. If you want to be able to write to it, add rw after root=/dev/sda in the Kernel parameters:

qemu-system-x86_64 -nographic -kernel linux-4.20.6/arch/x86/boot/bzImage -hda rootfs.img -append "root=/dev/sda rw console=ttyS0" -s

Bonus: Networking

You can create a point to point link between the QEMU VM and the host using a TAP interface.

First install tunctl and create a persistent TAP interface to avoid running QEMU as root:

sudo apt install uml-utilities
sudo sudo tunctl -u $(id -u)
Set 'tap0' persistent and owned by uid 1000
sudo ip link set tap0 up

Now launch QEMU with a virtual e1000 interface connected the host’s tap0 interface:

qemu-system-x86_64 -nographic -device e1000,netdev=net0 -netdev tap,id=net0,ifname=tap0 -kernel linux-4.20.6/arch/x86/boot/bzImage -hda rootfs.img -append "root=/dev/sda rw console=ttyS0" -s

Once the guest boots up, bring the network interface up:

ip link set enp0s3 up
ip a
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
    link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
    inet 127.0.0.1/8 scope host lo
       valid_lft forever preferred_lft forever
    inet6 ::1/128 scope host 
       valid_lft forever preferred_lft forever
2: enp0s3: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc pfifo_fast state UP group default qlen 1000
    link/ether 52:54:00:12:34:56 brd ff:ff:ff:ff:ff:ff
    inet6 fe80::5054:ff:fe12:3456/64 scope link 
       valid_lft forever preferred_lft forever

QEMU and the host can now communicate using their IPv6 Link-local addresses. After all, it is 2019.

Copypasta

# Building a minimal debuggable Kernel
make defconfig
make kvmconfig
./scripts/config -e CONFIG_DEBUG_INFO -d CONFIG_RANDOMIZE_BASE -d CONFIG_MODULES
make olddefconfig
make -j4


# Create root filesystem
qemu-img create rootfs.img 1G
mkfs.ext4 rootfs.img
mkdir mnt
sudo mount -o loop rootfs.img mnt/
sudo debootstrap bionic mnt/

# Add following lines to mnt/etc/systemd/system/serial-getty@ttyS0.service.d/autologin.conf
# START
[Service]
ExecStart=
ExecStart=-/sbin/agetty --noissue --autologin root %I $TERM
Type=idle
# END

# Unmount the filesystem
sudo umount mnt

# Boot Kernel with root file system in QEMU
qemu-system-x86_64 -nographic -kernel linux-4.20.6/arch/x86/boot/bzImage -hda rootfs.img -append "root=/dev/sda rw console=ttyS0" -s

# Attach gdb
gdb ./linux-4.20.6/vmlinux 
(gdb) target remote :1234

Books I Read in 2017

Wed, 09 May 2018 20:28:40 +0530

The God of Small Things by Arundhati Roy

A beautifully heart-rending exploration of the human condition. The prose is almost lyrical and the narrative is dreamlike and completely immersing. All the little details add up to symbolise something bigger. The book is part political satire, part social commentary part psychological drama and part fairy tale. In the midst of all this, it manages to capture the thought process of children like no other book. Would highly recommend.

How To Win Friends And Influence People by Dale Carnegie

The original “self-help” book. Carnegie offers solid advice for dealing with business relationships and public speaking. While some of it may be obvious, it’s especially useful for introverts and people with social anxiety because it outlines a few simple techniques that make meeting new people a little easier. However, some of the techniques for conflict resolution come across as outright manipulative. I doubt it will be life-changing but if you’re going to read a self-help book, you could certainly do a lot worse than How to Win Friends. Would recommend.

The Martian by Andy Weir

While the movie was great, the book is just so much better. A gripping page-turner with a focus on realism and scientific accuracy. Anyone even remotely interested in science and technology would find an immensely relatable hero in Mark Watney. To top off the exciting plot, the writing is crisp, the pacing perfect and the dialogue is brilliant and funny. Would highly recommend.

Restart: The last chance for the Indian Economy by Mihir Sharma

A blunt, irreverent and acerbic account of the long list of policy blunders which ail India’s economy. Probably the most well stated and researched rant you’ll ever read. The book is filled with anecdotes that are both insightful and funny. While Mihir Sharma jumps the gun with his suggestion in a few places, the work makes it absolutely clear that he knows what he’s talking about. He also breaks from the tradition of lionising India’s IT and pharma industries and calls them out for what they are. Would recommend.

The Curious Incident of the Dog in the Night-Time by Mark Haddon

A touching and poignant account of an autistic savant’s attempt to solve mysteries. The book does a wonderful job of capturing the perspective of someone with a thoroughly logical mind and difficulties interacting with other people. It also manages to convey the frustrations of those who care for children with special needs. An excellent if psychologically dissociating read. Would recommend.

The Emperor of All Maladies by Siddhartha Mukherjee

A biography of cancer punctuated with the experiences of the author as a practising oncologist. A perfect blend of scientific exposition and dramatic narrative. The vivid descriptions of biological processes are accessible and the metaphors absolutely exemplary. Also included is a history of the propaganda war waged by tobacco companies and cancer researchers. If you were unaware of the state of contemporary cancer treatments, it will leave you a lot more informed but possibly also a bit worried. Would recommend.

Midnight’s Children by Salman Rushdie

A story that willfully defies description. Notionally about 1001 children whose destinies are magically intertwined with that of independent India. A narrative packed with digressions, deliberate false steps and allegorical insinuations coupled with immensely funny and brilliant prose. The book captures the essence of everyday Indian life with both the magnificent and the squalid. Would recommend.

Sapiens: A Brief History of Humankind by Yuval Noah Harari

Like Guns, Germs and Steel but even grander. The sort of book that completely changes one’s perspective. The book is full of big ideas ranging from the power of collective delusions, the relationship between wheat and humans and the deep unconscious effects of advertising. Hands down the best book I read in 2017. Would highly recommend.

Norse Mythology by Neil Gaiman

A short but gripping and suspenseful retelling of the foundational myths of the Norse pantheon; stories of how Odin, Thor and Loki came to be and how they would fall. The prose is full of witticisms and frequently blurs the distinction between metaphor and reality. Overall, a delightful read. Would Recommend.

The Selfish Gene by Richard Dawkins

An immensely readable treatise on the gene-centred view of evolution by the high priest of New Atheism. The title really does the book injustice, it deals as much with the altruism of individuals as it does with the selfishness of genes. Dawkins also introduces the concept of a meme: a unit for human cultural evolution. Would highly recommend.

Fahrenheit 451 by Ray Bradbury

A dystopian novel about a future where books are outlawed and firemen burn any that are found. It can be read both as a criticism of censorship as well as that of mass media. Perhaps the second theme is more relevant today in the age of viral media than it was in Bradbury’s time. While a good read overall, the prose does come off as a bit snobbish. Would recommend.

Black Swan by Nassim Taleb

An annoyingly long-winded, insufferably pompous and thoroughly grating account of the disproportionate effects of unforeseen events. Much of the book reads like a self-aggrandizing rant. While there are a few good ideas in the book, it could have easily been cut to a third of its size without losing anything of value. Skip the book and listen to one of Taleb’s lecture instead. Would not recommend.

Foucault’s Pendulum by Umberto Eco as translated by William Weaver

Described as The Thinking Man’s Da Vinci Code, it’s a satirical exposition of people’s desire to believe their own version of the truth. Chock full of allusions and references, and incredibly dense, it certainly is not an easy or light read. The plot and characters are hilarious and the writing extremely clever. Reading this, one might end up feeling mentally inadequate. Would recommend.

The Raj at War by Yasmin Khan

Subtitled A People’s History of India’s Second World War, Yasmin Khan does an excellent job collating the experiences of ordinary Indians caught up in the war. There are accounts of not just soldiers but also lascars, nurses, labourers and peasants. The horrors of the Bengal famine are captured in all its gory detail. Also shown is the birth of India’s all-powerful and hopelessly apathetic babudom and the police state. Would recommend.

Snow Crash by Neal Stephenson

An absurdist, dystopian science fiction novel dealing with elements of history, linguistics, anthropology, religion, computer science, politics, cryptography, memetics and philosophy. Primarily, the plot revolves around information and how it affects humans. The difference between the workings of a man (Or for that matter, a beast) and a machine is frequently blurred to great effect. The book also popularised the term avatar meaning a virtual persona. Would recommend.

Deep Work by Cal Newport

The subtitle, Rules for Focused Success in a Distracted World is a definite oversell. It starts off decently. The premise of modern work environments that prioritize superficial and immediate metrics over creating actual value is spot on, as is the description of viral social media platforms stealing our attention and our ability to focus. The meat of the book though, the rules are the usual self-help claptrap full of anecdotes with a dash of survivorship bias. Nevertheless, the initial part of the book makes for good reading. Some might even find the rules useful. Would recommend.

A Clockwork Orange by Anthony Burgess

An unabashedly dark and satirical take on the morality of free will. The many depictions of violence carry a sense of excitement from Alex, the central character but, the book does not in any way promote violence. Large parts of the book are written in a fictional Russian influence slang which feels very natural while not harming intelligibility. The writing has an almost lyrical quality to it, especially when describing music. A short but unsettling read. Would recommend.

Talk @ RFC's We Love: CoAPing with the Internet of Things

Sat, 14 Oct 2017 11:56:27 +0530

Gave an introductory talk on CoAP at the 5th RFC’s We Love meetup. Turnout was low, probably owing to the rains and the festive season. It was still fun and had great discussions.

DCCP: The socket type you probably never heard of

Tue, 13 Dec 2016 23:10:50 +0530

TL;DR: DCCP is a relatively newer transport layer protocol which draws from both TCP and UDP. Jump straight to the example C code.

Background

Historically, the majority of the traffic on the Internet has been over TCP which provides a reliable connection-oriented stream between two hosts. UDP has been mainly used by applications whose brief transfers would be unacceptably slowed by TCP’s connection establishment overhead or those for which timeliness is more important than reliability. However, the increasing use of UDP for applications such as internet telephony and streaming media which transfer a large amount of data can lead to significant network congestion. Since unlike TCP, UDP provides no inherent congestion control mechanism, an application can send UDP datagrams at a much higher rate than the available path capacity and cause congestion along the path. Increased congestion may lead to delays, packet loss and the degradation of the network’s quality of service.

Applications and protocols that choose to use UDP as their transport must, therefore, employ mechanisms to prevent congestion and to establish some degree of fairness with concurrent traffic so that the network remains usable. A prominent example of such a congestion control scheme is LEDBAT employed by BitTorrent. However, implementing a congestion control scheme is difficult, time-consuming and error-prone. Multiple non-standard implementations also make it difficult to reason about how applications would respond to network congestion. DCCP - Datagram Congestion Control Protocol is intended to mitigate this problem as a transport for unreliable datagrams with built-in congestion control.

From an application programmer’s perspective, DCCP differs from UDP by providing four additional features:

Explicit connection establishment between hosts
Selectable congestion control schemes
Path MTU discovery to avoid fragmentation
Service Codes for identifying applications

DCCP makes use of Explicit Congestion Notification but it is transparent the application. DCCP is designed to leave additional functionality such as reliability or Forward Error Correction (FEC) to be layered on top, as and when required rather than at the protocol level itself.

Explicit connection establishment

The connection establishment semantics of DCCP mirror those of TCP with a client that actively connects to a server that is passively listening on a port. DCCP connections are bidirectional. Logically, however, a DCCP connection consists of two separate unidirectional connections, called half-connections. Each half-connection is a one-way, unreliable datagram pipe. The rationale for this explained in the next section.

Selectable congestion control schemes

TCP implements congestion control entirely transparently to the application. While it is possible to configure the host to use a specific variant, there is no way for the application to discover which congestion control scheme is in force, let alone negotiate one. DCCP, however, can cater to the different needs of applications by allowing applications to negotiate the congestion control schemes. In fact, each of the half-connections can use a different scheme, allowing for greater control.

Congesting the network by sending data at a rate that is faster than the slowest link between the endpoints will overwhelm it. This may lead to packet loss leading to retransmissions which may, in turn, lead to further congestion. The solution to this problem is to start transmitting data at a slow rate on a new connection and to then ramp up the speed until packet loss is detected. The transmission rate may then be scaled back until no further packet loss occurs. The optimum speed at which to transfer data will change with network conditions over the life of the connection. Congestion control schemes differ in how packet loss is estimated and the rate at which is the transmission speed is ramped up or scaled back. DCCP congestion control schemes are denoted by Congestion Control Identifiers - CCIDs. Currently, three CCIDs have been formally specified:

CCID 2 - TCP-like Congestion Control: A quick reacting scheme modelled after TCP which will rapidly ramp up speed to take advantage of available bandwidth and also rapidly scale back when congestion is detected. Suitable for applications that can handle large swings in transmission rates.
CCID 3 - TCP-Friendly Rate Control (TFRC): A slower reacting scheme intended to be friendly to concurrent TCP flows in the network. Provides a relatively smoother sending rate at the expense of possibly not utilising all available bandwidth. Suitable for media streaming applications that prefer to minimise abrupt changes in the sending rate.
CCID 4 - TCP-Friendly Rate Control for Small Packets (TFRC-SP): An experimental scheme for applications that use a small datagram size and those that change their sending rate by varying the datagram size.

In addition, the Linux kernel’s DCCP Test Tree contains an experimental implementation of a scheme modelled after TCP CUBIC. There is also a mode that disables congestion control altogether for UDP-like behaviour.

PMTU discovery

Data between two internet hosts is transferred transmitted as a series of IP packets that pass through intermediate links. Each of these links has a maximum packet size or maximum transmission unit (MTU) that it can transmit without having to break it up into smaller fragments. The largest packet size that does not require fragmentation anywhere along a path is referred to as the path maximum transmission unit or PMTU. Applications can usually get better error tolerance by producing packets smaller than the PMTU. DCCP defines a maximum packet size (MPS) based on the PMTU and the congestion control scheme used for each connection. DCCP implementations will not send any packet bigger than the MPS and instead return an appropriate error to the application. The application can query the DCCP stack for the current MPS and restrict itself from sending datagrams larger than this value and thereby avoid fragmentation.

Service Codes

DCCP defines a 32 bit Service Code to disambiguate between multiple applications associated with a single a server port. The client specifies the Service Code it wants to connect to and this is used to identify the intended service or application to process a DCCP connection request. Essentially, Service Codes provide an additional level of indirection for connection multiplexing. A server listening on a port may be associated with multiple Service Codes but a client may have only one Service Code, indicating the application it wishes to connect to.

Usage

The mainline Linux kernel has included DCCP support since 2.6.14 and mainstream distributions like Ubuntu enable it by default. However, to get the newer experimental features, you will have to build the kernel from the DCCP Test Tree. Or you can also grab the latest stable kernel release merged with the experimental DCCP changes from here. Be sure to enable all the CCIDs in the kernel configuration in Networking Support –> Networking Options –> The DCCP Protocol –> DCCP CCIDs Configuration. Like the Debian Installation Guide Says, “Don’t be afraid to try compiling the kernel. It’s fun and profitable.” For now, Linux is the only operating system supporting native DCCP, unless you count the patch for an ancient version of FreeBSD.

Example in C

The server and client look almost exactly the same as their TCP counterparts with the exception fo the socket type and setting of the service code. The client uses getsockopt() to read the current maximum packet size. Reading the available CCIDs on the host is shown in probe.c. As libc doesn’t still have a netinet/dccp.h header, you will have to get the required constants from the kernel sources or directly use the dccp.h header below. Download Code

server.c

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#include "dccp.h"

#define PORT 1337
#define SERVICE_CODE 42

int error_exit(const char *str)
{
	perror(str);
	exit(errno);
}

int main(int argc, char **argv)
{
	int listen_sock = socket(AF_INET, SOCK_DCCP, IPPROTO_DCCP);
	if (listen_sock < 0)
		error_exit("socket");

	struct sockaddr_in servaddr = {
		.sin_family = AF_INET,
		.sin_addr.s_addr = htonl(INADDR_ANY),
		.sin_port = htons(PORT),
	};

	if (setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, &(int) {
		       1}, sizeof(int)))
		error_exit("setsockopt(SO_REUSEADDR)");

	if (bind(listen_sock, (struct sockaddr *)&servaddr, sizeof(servaddr)))
		error_exit("bind");

	// DCCP mandates the use of a 'Service Code' in addition the port
	if (setsockopt(listen_sock, SOL_DCCP, DCCP_SOCKOPT_SERVICE, &(int) {
		       htonl(SERVICE_CODE)}, sizeof(int)))
		error_exit("setsockopt(DCCP_SOCKOPT_SERVICE)");

	if (listen(listen_sock, 1))
		error_exit("listen");

	for (;;) {

		printf("Waiting for connection...\n");

		struct sockaddr_in client_addr;
		socklen_t addr_len = sizeof(client_addr);

		int conn_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &addr_len);
		if (conn_sock < 0) {
			perror("accept");
			continue;
		}

		printf("Connection received from %s:%d\n",
		       inet_ntoa(client_addr.sin_addr), ntohs(client_addr.sin_port));

		for (;;) {
			char buffer[1024];
			// Each recv() will read only one individual message.
			// Datagrams, not a stream!
			int ret = recv(conn_sock, buffer, sizeof(buffer), 0);
			if (ret > 0)
				printf("Received: %s\n", buffer);
			else
				break;

		}

		close(conn_sock);
	}
}

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <errno.h>

#include "dccp.h"

int error_exit(const char *str)
{
	perror(str);
	exit(errno);
}

int main(int argc, char *argv[])
{
	if (argc < 5) {
		printf("Usage: ./client <server address> <port> <service code> <message 1> [message 2] ... \n");
		exit(-1);
	}
	struct sockaddr_in server_addr = {
		.sin_family = AF_INET,
		.sin_port = htons(atoi(argv[2])),
	};

	if (!inet_pton(AF_INET, argv[1], &server_addr.sin_addr.s_addr)) {
		printf("Invalid address %s\n", argv[1]);
		exit(-1);
	}

	int socket_fd = socket(AF_INET, SOCK_DCCP, IPPROTO_DCCP);
	if (socket_fd < 0)
		error_exit("socket");

	if (setsockopt(socket_fd, SOL_DCCP, DCCP_SOCKOPT_SERVICE, &(int) {htonl(atoi(argv[3]))}, sizeof(int)))
		error_exit("setsockopt(DCCP_SOCKOPT_SERVICE)");

	if (connect(socket_fd, (struct sockaddr *) &server_addr, sizeof(server_addr)))
		error_exit("connect");

	// Get the maximum packet size
	uint32_t mps;
	socklen_t res_len = sizeof(mps);
	if (getsockopt(socket_fd, SOL_DCCP, DCCP_SOCKOPT_GET_CUR_MPS, &mps, &res_len))
		error_exit("getsockopt(DCCP_SOCKOPT_GET_CUR_MPS)");
	printf("Maximum Packet Size: %d\n", mps);

	for (int i = 4; i < argc; i++) {
		if (send(socket_fd, argv[i], strlen(argv[i]) + 1, 0) < 0)
			error_exit("send");
	}

	// Wait for a while to allow all the messages to be transmitted
	usleep(5 * 1000);

	close(socket_fd);
	return 0;
}

probe.c

#include <stdio.h>
#include <sys/socket.h>
#include <netinet/in.h>

#include "dccp.h"

int main()
{
	int sock_fd = socket(AF_INET, SOCK_DCCP, IPPROTO_DCCP);

	// Check the congestion control schemes available
	socklen_t res_len = 6;
	uint8_t ccids[6];
	if (getsockopt(sock_fd, SOL_DCCP, DCCP_SOCKOPT_AVAILABLE_CCIDS, ccids, &res_len)) {
		perror("getsockopt(DCCP_SOCKOPT_AVAILABLE_CCIDS)");
		return -1;
	}

	printf("%d CCIDs available:", res_len);
	for (int i = 0; i < res_len; i++)
		printf(" %d", ccids[i]);

	return res_len;
}

dccp.h

/* This file only contains constants necessary for user space to call
 * into the kernel and thus, contains no copyrightable information. */

#ifndef DCCP_DCCP_H
#define DCCP_DCCP_H

// From the kernel's include/linux/socket.h
#define SOL_DCCP                        269

// From kernel's include/uapi/linux/dccp.h
#define DCCP_SOCKOPT_SERVICE            2
#define DCCP_SOCKOPT_CHANGE_L           3
#define DCCP_SOCKOPT_CHANGE_R           4
#define DCCP_SOCKOPT_GET_CUR_MPS        5
#define DCCP_SOCKOPT_SERVER_TIMEWAIT    6
#define DCCP_SOCKOPT_SEND_CSCOV         10
#define DCCP_SOCKOPT_RECV_CSCOV         11
#define DCCP_SOCKOPT_AVAILABLE_CCIDS    12
#define DCCP_SOCKOPT_CCID               13
#define DCCP_SOCKOPT_TX_CCID            14
#define DCCP_SOCKOPT_RX_CCID            15
#define DCCP_SOCKOPT_QPOLICY_ID         16
#define DCCP_SOCKOPT_QPOLICY_TXQLEN     17
#define DCCP_SOCKOPT_CCID_RX_INFO       128
#define DCCP_SOCKOPT_CCID_TX_INFO       192

#endif //DCCP_DCCP_H

Caveats and Conclusion

DCCP is not mainstream. It is not widely deployed or even supported. Documentation is sparse. Although Linux DCCP NAT is functional, many intermediate boxes will probably just drop DCCP traffic. DCCP is the Fixed-gear bicycle of Layer 4, it is the ultimate hipster transport.

Books I Read in 2015

Sun, 03 Jan 2016 21:36:15 +0530

India After Gandhi by Ramachandra Guha

A thoroughly sourced, brilliantly written and mostly objective history of India. Guha’s scholarship and unbiased account really shines throughout the book. Save for one non-sequitur and one inaccurate and one might say unfair characterization there is nothing to complain about. The rare photographs included in the book are fascinating by themselves. Reading the book makes you wonder if it is Indian history itself or Guha’s writing that makes it such a page turner. Definitely the best book I’ve read this year. Would recommend.

Patriots and Partisans by Ramachandra Guha

A collection of essays on India from a self proclaimed liberal centrist. Chock full of telling anecdotes and witty insights. While it is interesting on it’s own, it is nowhere as gripping as India After Gandhi. Guha is definitely a better scholar than he is a polemicist but he really excels as a storyteller. The chapter describing how the Congress Dynasty and its sychophants destroyed an insititution Guha personally cherished was probably the best of the lot. Would recommend.

Ramayana by Valmiki as retold by C. Rajagopalachari

A highly condensed and simplified retelling of the timeless epic from one bhakta intended for prospective young bhaktas. But for me, Rajaji’s commentary and comparison between different versions of the epic are more interesting than the actual narrative. The standard trope of digressing to heap praise on the protagonist slackens the pace and gets rather irritating after the first few times. So irritating that finishing this book took me far longer than it should have, given its size. Would not recommend.

Picture of Dorian Grey by Oscar Wilde

Beneath the endlessly quotable characters and beyond the absurd supernatural premise lies a much deeper message. Or possibly several such messages. Sadly, I for one have no idea what they are supposed to be. Wilde’s self-indulgent prose aside, I found the book incredibly difficult to read and had to force myself to finish it. Unlike almost everyone else I know who has read the book, it had no discernible impact on me except for making me a little more choosy about what I read. Would not recommend

A Short History Of Nearly Everything by Bill Bryson

A very lucid and easily digestible survey of what we know and how we know what we know. Funny, insightful and entertaining, Bryson’s curiosity and style makes even geology seem interesting. While doing a good job of explaining the science and the history behind the science, it also manages to capture the human side of the countless passionate men and women who dedicate their lives to advancing the state of human knowledge. Would recommend.

The Ultimate Hitchhiker’s Guide to the Galaxy by Douglas Adams

Technically not one book but “a trilogy of five”. The Hitchhiker’s Guide to the Galaxy and The Restaurant at the End of the Universe are absolutely hilarious. Life, the Universe and Everything, So Long, and Thanks for All the Fish and Mostly Harmless are slightly less so. It’s probably a bad idea to go through all of them in one go because the absurdity gets a little too much to handle. An otherwise brilliant collection. Would recommend.

Siddhartha by Hermann Hesse as translated by Hilda Rosner

The best thing about this book is its size. At barely 150 pages, you don’t waste too much time on this New Age twaddle full of knowing smiles, hearts spontaneously bursting with joy and characters who for some reason resemble various fruit and vegetables. Much like the narrative, Hesse’s attempt at reproducing Sanskrit idioms feels jarring and pointless. The only realization I had from reading this book was that the eponymous protagonist went about the ashramas of life in a vipareeta order. Would not recommend.

Train to Pakistan by Khushwant Singh

A fictional account of a very real disaster. Kushwant Singh’s prose is simple, engaging and very readable. The characters and the setting feel all too familiar and real as do the norms and social memes. The book does a very good job of capturing the senselessness of the violence and the tribal rationalizations invoked to justify it. The ending, while a little over the top, does manage to leave an emotional impact. Would recommend.

If It’s Monday It Must Be Madurai by Srinath Perur

This was the first travel book I’ve ever read and it did not disappoint. Perur’s book is as much about the people he traveled with and their reasons for travelling as it is bout the places themselves. The observations of the stereotypical Indian traits and notions are spot on and the commentary is effortlessly funny. The book is perhaps more accurately subtitled A Conducted tour of the Indian Traveler. Would recommend.

Brave New World by Aldous Huxley

The book most frequently compared to and contrasted with George Orwell’s dystopian 1984. Huxley’s take on dystopia is an anti-utopia centered around the cult of Henry Ford. While the premise is decent, the over the top caricature of Fordian society as the opposite of what is Huxley’s sense of morality does reduce the overall impact and the result is no where as haunting as 1984’s Big Brother. The book is short enough to finish in a couple of sittings and it is probably best to finish it quickly as I found it difficult to read when stretched out. Would recommend.

The Accidental Prime Minister by Sanjaya Baru

After the 2008 financial crisis, as major economies of the world went into recession, the Indian growth story seemed to remain intact. International journalists looking for post hoc explanation began to hail Dr. Manmohan Singh as the economist prime minister who held it together. Unblemished by the taint of corruption that was to follow, at this point Dr. Singh enjoyed international recognition and renown. In this supposed tell-all book, Sanjaya Baru claims credit for the successful PR campaign he undertook as the PM’s spin doctor. While book is in no way a revelation, it does flesh out the details and put things into perspective about how the UPA government and the Congress party functioned. Would recommend.

Arthashastra by Kautilya as translated and rearranged by L.N. Rangarajan

As if taking a cue from the success of Art of War themed self-help books, distilled Kautilyan teachings re-purposed for the modern corporate have become popular of late. Not wanting to be given truisms of some random author’s reading into Kautilya, I went to the original source. While I couldn’t find any universally applicable ancient wisdom, reading the Arthashastra was enjoyable. Rather than the simplified, whitewashed and sometimes politically colored descriptions of ancient India of history books, the Arthashastra is a contemporary insider’s account of ancient Indian society or at least an idealized conception of it. But given its nature, the book is filled with lists and tables and permutations and gradations. Skimming through these and focusing on more subjective descriptions makes for a very interesting reading. Would recommend.

Burmese Days by George Orwell

Based on Orwell’s time as an officer of the Indian Imperial Police, Burmese Days pulls no punches while describing the colonial experience. The hypocrisy and cognitive dissonance of the British, the opportunism and corruption of native officials, the vanity and the pointless pursuit of prestige by everyone involved, the frustrated attempts at finding love an companionship and finally the frailty of the human condition, Orwell tackles it all. While nowhere near as popular as Orwell’s other books, Burmese Days is certainly an excellent book. Would recommend.

Who Was Shivaji by Govind Pansare

This was not meant to be a book. Expanded from an earlier speech, Who Was Shivaji would have remained a niche political pamphlet hadn’t Govind Pansare been murdered in cold blood. The comrades of Left World Books seemed to have no ethical or ideological qualms about exploiting the death of its author. Even when printed using the ridiculously large font, the book still doesn’t reach a hundred pages. There just isn’t enough material to justify turning into a book. As for the material that is there, it is mostly unremarkable stuff. The most interesting parts of the book were actually the letters written by Shivaji, reproduced in the appendix. By far, the most disappointing book of the year. Would not recommend.

The Great Indian Novel by Shashi Tharoor

Puns, allusions and witticisms that’s what The Great Indian Novel is made of. The title being a reference to Mahabharata, Sashi Tharoor’s debut novel tells the story of modern India using characters from the epic. Tharoor’s style is engaging, extremely irreverent and incredibly funny. Taking shots at everyone from Gandhi to Nehru to the Indian media with a few self-referential jokes about NRI’s and diplomats thrown in for good measure. After an excellent start, and buildup, the plot sags a bit. Given the subject matter, there probably is no closure possible but the climax does feel a bit week. Overall a decent way to close the year. Would recommend.

Lazy Performance Comparison of WordPress and Ghost

Sat, 04 Apr 2015 18:40:03 +0000

So, I switched to a new blogging platform. Again. After trying out a static approach, I moved back to a WordPress when I stumbled across OpenShift (And their fantastic free plan). That was well over two years ago. In the meantime, I hardly blogged and didn’t really run into any issues but the blog did feel a tad sluggish.

Fast-forward to yesterday when I had a sudden impulse to try something new. Ghost looked interesting so, I spun up an install using OpenShift’s Ghost Quick-Start and proceeded to import data from my WordPress blog which turned out to be pretty painless.

Given the same resources (Small Gear) and same amount tweaking (i.e. none, using OpenShift’s quickstart installation defaults and using the default themes with no plugins), Ghost certainly felt a lot faster but how fast was it really? To answer that (And because I apparently have nothing better to do on a Friday night), I started a simultaneous stress test on WordPress and Ghost using BlazeMeter with a maximum of 50 users. The answer, as turns out is a helluva lot faster!

	Avg. Latency	Avg. Response Time	90%	95%	99%	Min	Max
Ghost	255.05	752.28	739	793	4647	602	7240
Wordpress	12129.55	21238.06	33641	37725	52178	2273	67093

On average, Ghost’s response is 28 times faster and its latency is 47 times lower. Looking at how the two respond to load is interesting:

Ghost doesn’t even seem to break a sweat while WordPress starts panting quite early into the run. The longest it took for Ghost to respond was 7240 ms which is almost a whole order of a magnitude faster than Wondpress’s 67093 ms. The shortest time for Ghost is 602 ms, a comfortable 3.77 times better than 2273 ms it took WordPress.

Basically Ghost crushes WordPress in this admittedly lazy and unscientific test. It is pretty similar to what others have reported. If your personal WordPress setup is struggling to keep up with traffic, you should at least consider Ghost. It doesn’t have anywhere near the number of plugins or themes as WordPress, it clearly is not as mature (It’s still in version 0.5.10) but boy is it fast! As for the writing flow, I can only say its different. I’m not entirely sure if it is better than what we have been used to (No spell check).

I for one am quite happy I tried (And switched to) Ghost. And I got a blog post out it to boot!

Art of Living Foundation's Kurshed Batliwala Debunked

Sun, 28 Jul 2013 10:07:52 +0000

A critical look at Khurshed Batliwala’s talk, “Technology of Spirituality” delivered at Ruia College, Mumbai.

Mr. Batliwala makes a number of extraordinary claims about the state of ancient Indian science and technology. Most of them however, turn out to be exaggerations, misinterpretations or outright fabrications. He then attributes all scientific progress to ‘spirituality’.

The talk is nothing more than a sales pitch for Mr. Mr. Ravi Shankar’s ‘Art of Living Foundation’.

Talk @ EmWare: Getting started with Linux

Mon, 27 May 2013 06:30:00 +0000

Gave an introductory talk on Linux, basically a rehash of the talk I gave at KLU a couple of years ago.

Talk @ EmWare: Getting Started with Git

Fri, 17 May 2013 06:30:00 +0000

Gave an introductory interactive tutorial on using Git. I couldn’t finish the slides on time but managed cover everything on the agenda.

Now that the talk is done, I’m don’t feel especially inclined to complete the slides.

Defeating India's Central Monitoring System

Thu, 09 May 2013 14:08:00 +0000

The Government of India has rolled out the Central Monitoring System which will allow it to access any piece of data passing through an Indian service provider. This means the government can now read all your text messages, emails and call records.

Because privacy does not bring in votes, it is highly unlikely that any political party will oppose this system. Circumventing this system however, is rather simple using PGP or any other munition grade cryptographic scheme. So, if anyone wishes to communicate with me securely, please encrypt your message using this key, whose fingerprint should be:

```AA3C 18D8 88D6 EC67 6887 2B21 5D64 D65C 162D 0A3C```

You may now put your tin-foil hat back on again.

Edit: Replaced my old key with a 4096-bit RSA key.

Hello Again, World!

Tue, 19 Feb 2013 17:59:29 +0000

Here it goes again: After a couple of attempts with Blogger, a dozen iterations with WordPress, a very brief tryst with Drupal and a false start with Bloggart, I’ve now decided to ditch dynamic content management systems and give Octopress a spin.

I like the idea of a statically generated site I can deploy anywhere. I used Sphinx for a documentation once and the experience with was pretty good. However, getting Sphinx to work for a personal blog seemed to be too much work, so Octopress it is. So far I’m really happy with Octopress and with minimal tweaking, I have all the functionality I need. Hopefully, I will stick with it and actually blog this time around. Fingers crossed!

Das Blinkenlights on the MSP430 Launchpad with Linux

Sat, 12 Jan 2013 19:06:05 +0000

TI’s MSP430 LaunchPad development kit offers some serious bang for the buck. You get two modern 16-bit microcontrollers, a programmer-cum-debugger with pins broken out and a USB cable for less than 5 USD inclusive of shipping. TI even provides two free (as in beer) IDE’s for Windows. Linux support though was a bit sketchy when the board was first released.

Things of course have greatly improved and getting the Launchpad to work with Linux is now a breeze. The versions of MSPGCC and MSPDebug in Ubuntu 11.10’s repositories seem to work just fine. There’s also functional Arduino fork for the MSP430 called Energia.

Mole Nama: A Linux Fantasy Saga

Sun, 19 Aug 2012 18:23:22 +0000

Mole Nama
A historical account of the Mole’ani people in the Free Lands

-Inestimabel Montcastellus

We Mole’ani are a Geekic people, who like millions of other races call the Free Lands home. However, our people originally came from the other side; the Dark Lands that shall not be named. The Dark Lands were under monopolistic rule of the Borg and their brethren. Piracy was common and so were the viral diseases which accompanied the booty. Systemic crashes and ‘illegal operations’ were the order of the day. The Three Fingered Salute was often the only way out. But even then, there was the ever present danger of being crippled by a terrorizing bout of Blue Death.

In the midst of chaos, the Mole’ani saw hope. The communes of Firey Foxen and We El Sea brought some stability, the likes of which were never heard of in the Dark Lands. This coupled with the Enlightenment of Openness convinced our people that there was a better way.
While the Mole’ani were eager to move to where there was freedom and openness, obtaining a passage to the other side was difficult. With their limited means, they could only go as far as the Isles of Pupey before being forced to return to the Dark Lands.

Then came redemption. The Mole’ani came to know that Benevolent Emperor of Ubunatia, determined to assist people like them, had declared the Shipet campaign and sent out his fleet. Finally, our people were able to cross the Vu’Bee Strait, landing on Ubunatian coasts in the era of the Heron.

There, they quickly assimilated and became Ubunatians in name and spirit, severing their last ties to Darkness. The Mole’ani turned into missionary paladins, helping bring in dozens of new ally races into the Free Lands. Our people and our allies traveled widely across the Free Lands, touring Ubunatia’s vassal states Kubunatia and Zubunatia and even as far as the lands of the Scarlet Caps and Green Lizards.

The Mole’ani however remained loyal Ubunatians. There was minimal dissent even during the Directional Reform of the Lynx era.Things changed with the stirring of the Unitarian Revolution. Hoping to preserve their way of life, our people sought refuge in the vassal state of Zubunatia. Their attempts to change the Zubunatian system proved disastrous, forcing them to flee North and defect to the Mint Realm.

And our people remained in peace. However, trouble started once more. The Genom clergy’s antics had caused massive outrage across the Free Lands. Ubunatia, the region’s dominant power had already parted ways with the Genom during the Revolution and refused to have anything to do with it. Refugees fled to the North in their hundreds of thousands and the Mint Realm rose in defiance.

In the far away Archinan Republic, a group of dissidents splintered from the Genom and proclaimed the Path of Mayte to defend their cherished old ways. The Mint Realm, although skeptical about Mayte’s future, immediately declared its support to the fledgling movement.
At the same time, the Realm ennobled Sinamon to ensure the survival of the old ways.

In the midst of turmoil, the Mole’ani yearned for stability. They returned to the South and settled in the borderlands of Ubunatia and Zubunatia where they remain to this day.

Inspired by the Great Linux World Map.

Talk @ KLU: Linux? Say whaat?!

Mon, 17 Oct 2011 21:20:38 +0000

Gave an introductory talk on Linux at Koneru Lakshmiah University, with Vamsifollowing up with a talk on Bugs and Hacks as a part of the ‘workshop’ organised by the KLU Linux Users Group. With about 150 newbish students in attendance, it was fun albeit in a masochistic kind of a way.

Here’s a shitty picture from the talk, courtesy of Vamsi:

And here are the sildes:

Edit: I lost the slides. Only this sad screenshot remains :(

Hello, World!

Sun, 16 Oct 2011 17:57:01 +0000

This is the 11th iteration of my blog/homepage. I’ve finally found a setup that I like (Thanks to Bloggart!) and unless I run into any major issues, I’m probably going to stick with it. Maybe now I’ll finally stop resetting the site and get down to actually blogging!

Watch this space!