Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

It supports acting as a wifi hotspot. I've never tried it, but does that not work for local area networking with data off?

Also: http://multipath-tcp.org/pmwiki.php/Users/Android

The nice thing about Android is you get the source. If you want, you can add MultiPath TCP to Android.


I'd still love ad-hoc better. HotSpot allows you to share 4G through WiFi, but it doesn't scale. The hotspot because AP, and that's the center of the network. On contrast, ad-hoc can scale to thousands of nodes across miles by using multiple hops. Also, ad-hoc is a more distributed model.

I never understood why ad-hoc mode was disabled by driver. AP mode (hotspot) is still available; users can still share their 4G connection without being approved by their carrier.


Ad-hoc networking on wifi generally only supports point-to-point links, not routing, unless you use another routing protocol on top of it like BATMAN Advanced.

I'm not sure why connecting to an ad-hoc network is disabled in Android, but it's certainly never been anything that's caused me problems.


Right. But I supposed by hotspot/ad-hoc, we were talking about the link layer possibilities only. hotspot is also about MAC layer only as well. IP runs on top of that. However, the difference is that, in AP/client mode, all nodes need to associate with and be able to talk to an AP; while in ad-hoc mode, every node is equivalent and they can be as distributed as they want. For ad-hoc routing, there're olsrd, batman, etc. They are really cool :-)

We used to use Android devices to test different scenarios of ad-hoc applications. But none of current mainstream devices support ad-hoc mode any more. On contrast, iOS devices can still join (although not create) an Ad-Hoc network, which is ... ironic.


Probably not. A dedicated MITM attacker could simply strip off the MultiPath TCP options from the initial connection, so it would act merely as a regular TCP connection in that case.

Good crypto is a much better solution to minimizing the likelihood of a MITM attack. MultiPath TCP is design to provide speed, reliability, and mobility of TCP connections.


Integrated? I don't know about OpenBSD, but in Linux it is not in mainline. There is an experimental fork of the kernel supporting it, but it hasn't been proposed for merge upstream yet.

Sure, there has been development going on for years, but there are no major distros you can download and use it out of the box.

The point is, this is the first shipping product using it in the wild, as opposed to experimental implementations used in research and development.

Note that this is not multipath routing (which takes place at the IP layer, and requires involvement in routing protocols that end devices don't usually have access to), nor is it channel bonding (which occurs at the ethernet layer).


I stand corrected, is anyone trying to merge it?

EDIT: No I don't.


Not sure, there's no indication that I could find of a roadmap to merge on the Linux MultiPath TCP web site: http://multipath-tcp.org/


“The current implementation of Multipath TCP in the Linux kernel supports RFC6824 and includes this fallback mechanism.” - [About Measures][0]

0: http://multipath-tcp.org/pmwiki.php/Users/AboutMeasures

Please don't say things so scary without looking into it.


When they say that, they mean in their fork of the Linux kernel: https://github.com/multipath-tcp/mptcp not in the official upstream kernel from Linus https://git.kernel.org/cgit/linux/kernel/git/torvalds/linux.... nor any of the mainstream distro kernels.

You can check this for yourself. Just take a look for the MPTCP patches in Linus's kernel. You won't find them. Here's my kernel git repo; origin is Linus's repo, mptcp is the MPTCP development repo:

  $ git log --pretty=oneline origin/master..mptcp/mptcp_v0.87 | wc -l
       2841
As you can see, there are 2841 patches in the mptcp_v0.87 branch that are not in the kernel repo, all the way back to the original shim6 patch that was used to start building MPTCP on top of shim6, which was a proposal for multi-homed IPv6 (MPTCP now works on top of IPv4 as well).

Note that when you look at the "installing on Linux" instructions, they mention running it in a virtual machine.

This is not terribly uncommon for an ambitious research effort; work on an out of tree fork for a while, and then when it's ready, propose it for inclusion into the upstream kernel. For a recent example, see Bcache http://bcache.evilpiepirate.org/, which was developed out of tree for several years before being merged a few months ago.

> Please don't say things so scary without looking into it.

Why do you find this scary?

And why do you think that I didn't look into this?


Ahh, the way you said it made it sound like the first bit was you talking out your ass, assuming that they hadn't merged any of their work by a few pages on their site.

I am currently on a very restricted link, so I was not able to check the commit logs.


Multipath TCP sends packets over multiple paths; multiple different connections, such as cellular and WiFi. It doesn't repeat the packets, unless one of them is dropped. It can be used for several purposes; aggregating bandwidth between the paths, taking advantage of the bandwidth of both connections. It can be used for reliability. And it can be used for transparent handover of connections, where you may walk out of your house and switch over from WiFi to cellular seamlessly.

LWN has a good article on it: https://lwn.net/Articles/544399/


Multipath TCP could be used for smoothly handing over from the slower, more expensive, less-reliable cellular system, to the faster, cheaper, more reliable WiFi.

Without multipath TCP, you have to drop and restart each connection, which in some applications can cause hiccups, latency, or even complete loss of state.

Of course, all of this depends on server-side MPTCP support as well, which most systems don't ship with out of the box.


Right. What I'm saying is that, by keeping alive both path, you need to use some traffic. Although when there's WiFi available, you are primarily using WiFi, there are traffic going through cellular network in order to keep the path alive.


would be really cool if slower / more expensive connections could ultimately be drained, and the whole data transfer just switches over to a single more faster connection.

edit-1: note that this is not the same as subflow 'deletion' that would happen if an access mechanism was not available at all.

edit-2: section-3.4 of the mptcp paper indicates that FIN has a more limited 'no more data on this subflow' semantics. so, in theory it should be possible to do just that. would be so much better to not go the ANDSF route at all ;)


Hey! I didn't go into that deep! So if FIN is used in a subflow, does it terminate that path? Is it possible to wake this path up again?


the shorter answer first: i don't think there is any possibility of resurrecting a subflow once it is gone.

longer one: with mptcp, there needs to be some way to distinguish connection-teardown vs subflow-teardown. with, RST the subflow is terminated. FIN is more subtle (since it occupies the sequence space in normal tcp) however. FIN is handled via an explicit DATA-FIN within TCP option to indicate the end of data-sequence-space (which maps subflow sequence numbers to data sequence numbers in TCP options). gracefully terminating a connection, thus involves sending DATA-FIN on all subflows together with a FIN.


> to the faster, cheaper, more reliable WiFi

This is far from universally true and a wonderful illustration of why multipath is great: I frequently see wifi where the back link is down or behind a payment gateway, requiring me to turn off wifi to get a reliable connection. This is sadly common at conferences where the venue skimped on AP placement and left entire rooms at max range or with inadequate backhaul.

The true beauty of MPTCP is that you don't need to make assumptions and hope — instead we can let the kernel sort things out based on the current environment.


Cellular mobile units are likely to have a short dwell time on any particular WiFi if they are in a moving vehicle. Can the underlying connections be initialized quickly enough for this case?


> These positions are short term contract (6 months-1 year) and are not meant as long term employment.

From the article:

"Margaret Mary Vojtko... had taught French at Duquesne University for 25 years... Adjuncts now make up well over 50 percent of the faculty at colleges and universities."

And further information, with sources, backing this up: https://en.wikipedia.org/wiki/Professors_in_the_United_State...

Lots of colleges are hiring adjunct professors to teach undergraduate courses, rather than full tenure track professors. As they reduce their tenure track hiring and increase their hiring of adjunct professors, it stops being a short-term contract for a visiting professor, and becomes the only viable career path for many people in academia.

The problem is, when many people think of professors they think of the same tenure track professors that you're thinking of; fairly well paid, good benefits, great job security (once tenure has been achieved, that is; before that, the job security is pretty dicey), lots of academic freedom. What they don't realize is that more than half of actual professors are actually low-paid adjuncts with poor job security (and a good chunk of the rest are tenure track but don't yet have tenure).

On top of that, you have post-docs and grad students doing most of the actual research (and some of the teaching as well), and you realize that academia looks pretty grim. Low paid people with low to no job security perform most of the actual work, while people think of them as high-paid folks with strong job security.


This is made worse by the explosion in administrative staff at colleges and universities[1]. Universities in the US are more about running universities than they are about teaching students or doing research. Given administrators are sucking down huge gobs of money, the budget shortfall needs to be picked up somewhere, and that is where the rise of the adjunct professor comes in.

1. http://dailycaller.com/2013/03/28/study-school-administrativ...


I am unable to actually find an sort of source for the statistic that "Adjuncts now make up well over 50 percent of the faculty at colleges and universities."

It seems to go back to the SEIU, a group that is attempting to unionize adjunct positions. I have seen it quoted in a number of ways, including "50% of part time faculty at universities are adjunct." and "50% of teaching positions at universities are adjunct."

I would like to see some sort of actual report that shows the source of that. My (very limited, anecdotal) experience seems to indicate much fewer than 50% of professors are adjunct. It all depends on how you count these things.


Following the citation in the Wikipedia article to http://www.insidehighered.com/views/2007/11/13/hoeller which links to http://www.aaup.org/our-work/research which links to http://www.aaup.org/sites/default/files/files/AAUP_Report_In..., there's a chart on the first page with trends between 1975 and 2011.

In 1975, 45% of teaching staff was tenure or tenure-track, 34% non-tenure-track (full or part time), and 21% grad students. In 2011, it's 24% tenure or tenure track, 57% non-tenure-track, and 19% grad students.

Now, part-time employees may make up a smaller proportion of actual teaching time than full time, but remember also that tenure track professors and grad students spend time doing research as well, not all of their time is spent teaching.

How many of your professors did you know the status of? I know that that certainly wasn't something I kept close tabs on when I was in college; there were a few professors who I knew well enough to know their status as tenured, tenure track, or not tenure track, but for many I didn't pay attention. Many of the adjunct professors are likely teaching intro-level classes that everyone is required to take; your freshman English or writing or math requirements.

Also recall that the more prestigious the school, the less likelihood that they will rely heavily on adjunct professors. Smaller state schools, community colleges, and for-profit schools may use them more often. Edit to add: the AAUP has another report that breaks down the faculty by school, and you can clearly see that these kind of non-tenure track and part time professorships are much more common at community colleges, smaller less prestigious schools, and for-profit schools, with some of them having 100% contingent (non-tenure track) faculty: http://www.aaup.org/sites/default/files/files/AAUPContingent...

And further, they may be named different things, but be roughly equivalent in job security, prestige, and benefits. Lecturer, instructor, visiting professor, visiting lecturer, assistant or associate teaching professor, etc.


Nonetheless, the AAUP document seems to show that even at US public doctoral and research universities, in 2005 non-tenure-track employees made up about a quarter of the full-time faculty and about 40% of all faculty if you include the part-timers (p. 18). There's also the issue of graduate students who teach or do research work. The numbers apparently included teaching grad. students, but only those which had been self-reported by their institutions as "employees" rather than recipients of valuable teaching/research experience (p. 10): it's not hard to imagine some under-reporting there.


From an NYTimes article earlier this year [1]:

According to the report, [tenure and tenure-track] positions now make up only 24 percent of the academic work force, with the bulk of the teaching load shifted to adjuncts, part-timers, graduate students and full-time professors not on the tenure track.

The report was published by Center for the Future of Higher Education in 2012. Link: [2]

From the executive summary from this 2010 publication by the American Federation of Teachers [3]:

Altogether, part-time/adjunct faculty members account for 47 percent of all faculty, not including graduate employees. The percentage is even higher in community colleges, with part-time/adjunct faculty representing nearly 70 percent of the instructional workforce in those institutions.

[1] http://www.nytimes.com/2013/04/08/education/gap-in-universit... [2] http://www.insidehighered.com/sites/default/server_files/fil... [3] http://www.aft.org/pdfs/highered/aa_partimefaculty0310.pdf


"Percentage of teaching hours" or "percentage of teaching budget" seem like more useful statistics than "percentage of names on payroll".


Take a look at this report, which breaks down categories of professors by school, and you'll find that there are many schools for which contingent professors (non-tenure track) and grad students make up 100% of the teaching positions: http://www.aaup.org/sites/default/files/files/AAUPContingent...

Now, sure, they're mostly small community colleges or for-profit universities, but that is a significant chunk of the higher education system in the US.


SICP uses Scheme, not Common Lisp.

Scheme is a deliberately minimalist language, which is fairly accessible and easy to write your own implementation of. In fact, in SICP, you do that, a couple of times, writing first a Scheme interpreter, then extending it in various ways like adding logic programming capabilities, then you write a virtual machine and a compiler that compiles down to that virtual machine.

JavaScript is, well, a weird and warty language. You wouldn't want to try implementing JavaScript in an introductory CS class, and it's much less amenable to language extension like the logic programming variant of Scheme you implement in SICP.

But I notice that this translation of SICP into JavaScript doesn't got that far; it only goes up through Chapter 2 of SICP.


JavaScript is rather minimalist as well. It has some warts, but they are easy to avoid.


> Scheme is a deliberately minimalist language

Ever looked at R6RS?


I'm not a big fan of R6RS, but it is still fairly minimalist. One of the good things that it did was divide the standard into a core language, and standard library built on top of the small core language. The core language eliminated many things from R5RS, but the standard library adds a lot more.

The main issues I have with R6RS are the library system (which I think is too complex, and it frustratingly adds an extra level of indentation as you need to wrap everything in one big expression), and some of the libraries in the standard library, like the I/O library, the Unicode library (which standardizes on such things as char-upcase and char-downcase, which are fairly useless in a Unicode context, without adding much that's actually useful).

R6RS is this kind of weird, awkward beast that's not sure what it's doing. It neither strips the language down to a minimal core, nor does it build up a comprehensive set of libraries containing all of the basics that people expect from standard libraries in a language these days.


No, people don't directly fear it's backdoored by the NSA. There has never been any evidence that it's backdoored by the NSA. The algorithm it's documented as using (based on AES) is not the one that was backdoored by the NSA (Dual_EC_DRBG), though you would have to take a look at the chip with a scanning electron microscope in order to verify this.

The kernel developers just don't think it's a good idea to blindly trust unauditable hardware random number generators. Using it in conjunction with other sources of entropy is one thing; just using it on its own is putting a bit too much faith in it, especially because the code that uses it uses a generic wrapper for any hardware random number generation instruction, so if AMD or ARM or MIPS chips later come with random number generators, the kernel will be able to take advantage of their entropy without putting itself at risk if one of them is backdoored.

There's a difference between fearing that something is backdoored, and thinking that it's not a good policy not to blindly trust something.


Not sure if I'm reading the code correctly, but it seems like it mixes the hardware random bits with the output of what would be generated otherwise. I.e., Linux does not add the the RDRAND output to the entropy pool.

This means it might take more time to generate the required number of random bits. So not trusting RDRAND means a process might block waiting for random data.

Then again, hardware generators may be affected by external forces - other than the NSA. For example, CPU temperature.


Yes, that's right, the kernel doesn't add it to the entropy pool. RDRAND is a cryptographically secure pseudo-random number generator, it doesn't give you direct access to the full entropy of the hardware random number generator (that is planned with the RDSEED instruction, which isn't shipping yet[1]). RDRAND re-seeds a CSPRNG periodically with its hardware RNG, but it's not appropriate to feed directly in as the seed of another CSPRNG like Linux's /dev/random. Intel does provide a suggestion for how to ensure that it gets reseeded, so you can ensure you have seed-grade entropy in their software implementation guide[2]; it involves either calling it 1022 times, or running it 32 times with a 10 μs wait per iteration.

In Linux, there's a user-space deamon, rngd, that's responsible for mixing hardware random number generator entropy into the entropy pool. That's a more appropriate place to put the logic for adding entropy from RDRAND into the entropy pool; you probably don't want to be doing those 1022 iterations or 32 iterations with a sleep in between in the kernel itself.

The kernel just uses it as a parallel CSPRNG along with its own built in one. It runs its own, and RDRAND, and xors the results together. This allows it to get fast, good random numbers (which are important early in the boot sequence, for things like ASLR) even if its own entropy pool does not have very good entropy yet. This makes its random number generation at least as good as the stronger of RDRAND and the kernel's own CSPRNG. It does mean that if RDRAND (or some other processor's similar instruction, once other processors add it; it would be quite valuable on ARM and MIPS as embedded machines tend not to have very good entropy sources) is backdoored, and the kernel entropy pool has insufficient entropy, it may be possible for someone with knowledge of the backdoor to crack it, with a difficulty equal to the amount of entropy that the Linux entropy pool has. However, this is only true if you are using the non-blocking random number source, which tends to be used by things that need fast random numbers but don't need particularly good seed-grade entropy, like ASLR. If you need high-quality entropy, just use /dev/random and it will block until you have enough entropy to satisfy your request.

[1]: http://software.intel.com/en-us/blogs/2012/11/17/the-differe... [2]: http://software.intel.com/en-us/articles/intel-digital-rando...


So, when are we going to start seeing CVEs from these vendors, and updates to their software that disable this "feature"?

Cisco, Certicom, RSA, McAffee (via RSA), Juniper, Blackberry/RIM, OpenPeak, OpenSSL, Samsung, Symantec, Riverbed, Cummings Engineering, CoCo Communications, Kony, Lancope (via RSA), Mocana, Safenet, SafeLogic, Panzura, Microsoft, Thales e-Security, Catbird, ARX all list Dual_EC_DRBG as at least supported.

Of these, RSA (and presumably the others based on their, like McAffee and Lancope), Thales e-Security, and possibly Microsoft (Windows Server 2008 R2 lists only Dual_EC_DRBG, though its possible that that's just their only FIPS compliant one and they use some non-standard algorithm by default) seem to use Dual_EC_DRBG by default or as the only option. I haven't tried finding documentation on all of these to see if they say what their default algorithm is, so it may be more.

edit to add: Found this discussion on the OpenSSL users list, about why they added it. Apparently it was because a paying customer requested it, thought the customer is not named for confidentiality reasons. OpenSSL doesn't appear to enable the NIST/FIPS random number generators unless you compile it in FIPS mode (at least, as far as I can tell from a quick, their build system is a bit weird, and FIPS mode is even stranger):

http://marc.info/?l=openssl-users&m=137858935523161&w=2


Which Rust should help with as well, as long as people don't use unsafe pointers too much.

Of course, this is assuming Rust and Servo ever gain enough traction to build a viable browser; they're still at an early enough stage to be vulnerable to the problems lots of young, ambitious projects have, of taking on too much at once to ever be done enough for production use, interest petering out and never quite getting to the point of something widely usable (like Perl 6).


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: