curl cheat.sh — get an instant answer to any question on (almost) any programming language from the command line

tldr

do curl cht.sh/go/execute+external+program to see how to execute external program in go

And this question: why I actually should I start the browser, and the browser has to downloads tons of JS, CSS and HTML, render them thereafter, only to show me some small output,
some small text, number or even some plot. Why can't I do a trivial query from the command line
and instantly get what I want?

I decided to create some service that will work as I think such a service should work.
And that is how wttr.in was created.

Nowadays you probably know, how to check the weather from the command line, but if not:

curl wttr.in

or

curl wttr.in/Paris

(curl wetter in Paris if you want to know the weather in Paris)

After that several other services were created (the point was to check how good the console
can solve the task, so I tried to create services providing information
of various nature: text, numbers, plots, pseudo graphic etc.):

curl rate.sx/btc # to check exchange rate of any (crypto)currency
curl qrenco.de/google.com # to QRenco.de any text

And now last but not least, the gem in this collection: cheat.sh.

The original idea behind the service was just to deliver a various UNIX/Linux command line cheat sheets via curl. There are several beautiful community driven cheat sheet repositories such as tldr, but the problem is that to use them you have to install them first, and it is quite often that you have no time for it, you just want to quickly check some cheat sheet.

With cheat.sh you don't need to install anything, just do:

curl cheat.sh/tar (or whatever)

you will get a cheat sheet for this command (if such cheat sheet exists inf one of the most popular community-driven cheat sheet repositories; but it surely does).

But then I thought: why actually show only existing cheat sheets? Why not generate cheat sheets or better to say on the fly? And that is how the next major update of cheat.sh was created.

Now you can simply do:

curl cht.sh/python/copy+files
curl cht.sh/go/execute+external+program
curl cht.sh/js/async+file+read

or even

curl cht.sh/python/копировать+файл
curl cht.sh/ruby/Datei+löschen
curl cht.sh/lua/复制文件

and get your question answered
(cht.sh is an alias for cheat.sh).

And it does not matter what language have you used to ask the question. To be short, all pairs (human language => programming language) are supported.

One very important major advantage of console oriented interfaces is that they are easily
programmable and can be easily integrated with various systems.
For example, Vim and Emacs plugins were created by means of that you can
query the service directly from the editor so that you can just write your
questions in the buffer and convert them in code with a keystroke.

The service is of course far from the perfection,
there are plenty of things to be fixed and to be implemented,
but now you can see its contours and see the contours of this approach,
console oriented services.

The service (as well as the other mentioned above services) is opensource, its code is available here:
https://github.com/chubin/cheat.sh

What do you think about this service?
What do you think about this approach?
Have you already heard about these services before?
Have you used them?
If yes, what do you like about them and what are you missing?

Did you know, that adding the flag
"--libcurl" to you curl command, does actually create a .c file that you can compile and that tiny program will execute that exact command that you just performed in the terminal??
Example:
"curl http://linu.xxx/I_love_GOOGLE/4ever -# -k --libcurl"
It creates a .c file that perform that action when used.

"Pre-Installed Malware Found On 5 Million Popular Android Phones"
"added somewhere along the supply chain"

See below how to check if it's installed

Sources:

- (new) https://thehackernews.com/2018/03/...
- (new) https://research.checkpoint.com/rot...
- (old relevant news) https://thehackernews.com/2017/03/...

---

"Rottensys" a malware which covers devices from: Honor, Huawei, Xiaomi, OPPO, Vivo, Samsung and GIONEE

---

"According to our findings, the RottenSys malware began propagating in September 2016. By March 12, 2018, 4,964,460 devices were infected by RottenSys," researchers said.

"At this moment, the massive malware campaign pushes an adware component to all infected devices that aggressively displays advertisements on the device’s home screen, as pop-up windows or full-screen ads to generate fraudulent ad-revenues."

---

If you have one of the affected devices, here's how I checked mine:

1. Install ADB (Windows: https://forum.xda-developers.com/sh...)
2. Connect your device in USB-debugging mode
3. execute "adb shell 'pm list packages -f' > output.txt" (On windows navigate to C:\adb and replace "adb" with ".\adb.exe")
4. open the now created output.txt
5. search for any of those:

com.android.yellowcalendarz (每日黄历)
com.changmi.launcher (畅米桌面)
com.android.services.securewifi (系统WIFI服务)
com.system.service.zdsgt

To whoever messed with my devrant-client tests by constantly downvoting the posts and them being hidden from the API, you're a cunt and I hope you break your neck falling out a 12 story building. :)

Here's the final test to verify shit works too: https://devrant.com/feed/recent

Edit: it works, get fucked you humid piece of shit.

Edit2: To give context to whoever might be subscribed to me and might or might not have been bombed with notifications:

Was working on the plugin system for the devrant client and async was giving me hell, the links I posted were to test the plugin that first has to execute a $.get and only then can return a linkified rant-text.

That would probably be implementing multithreading in shell scripts.

https://gitlab.com/netikras/bthread

The idea (though not the project itself) was born back when I still was a sysadmin. Maintaining 30k servers 24/7 was quite something for a team of merely ~14 people. That includes 1st line support as well.

So I built a script to automate most of my BAU chores. You could feed a list of servers - tens or hundreds or more - and execute the same action on each of them (actions could be custom or predefined in the list of templates). Neither Puppet nor Chef or Ansible or anything of sorts was consistently deployed in that zoo, not to mention the corp processes made use of those tools even a slower approach than the manual one, so I needed my own solution.

The problem was the timing. I needed all those commands to execute on all the servers. However, as you might expect, some servers could be frozen, others could be in DMZ, some could be long decommed (and not removed from the listings), etc. And these buggars would cause my solution to freeze for longer than I'd like. Not to mention that running something like `sar -q 1 10` on 200 servers is quite time-consuming itself :)

And how do I get that output neatly and consistently (not something you'd easily get with moving the task to a background with '&'. And even with that you would not know when are all the iterations complete!)?

So many challenges...

I started building the threading solution that would

- execute all the tasks in parallel
- do not write anything to disks
- assign a title to each of the tasks
- wait for all the tasks to complete in either
> the same sequence as started
> as soon as the task finishes

- keep track of each task's
> return code
> output
> command
> sequence ID
> title

- execute post-finish actions (e.g. print to the console) for each of the tasks -- all the tracked properties are to be accessible by the post-finish actions.

The biggest challenges were:
a) how do I collect all that output without trashing my filesystems?
b) how do I synchronize all those tasks
c) how do I make the inception possible (threads creating threads that create their own threads and so on).

Took me some time, but I finally got there and created the libbthread library. It utilizes file descriptors, subshells and some piping magic to concentrate the output while keeping track of all the tasks' properties. I now use it extensively in my new tools - the ones where I can't use already existing tools and can't use higher-level languages.

TIL Nginx supports js out of the box. You don’t need nodejs to write servers in js. You can install Nginx and make it execute js code to generate pages. It even supports TypeScript!

https://nginx.org/en/docs/njs/
https://nginx.org/en/docs/...

Regression testing is a type of software testing that is performed to ensure that changes or modifications made to an existing software application do not have any adverse effects on the functionality of the system. It is typically performed after bug fixes, enhancements, or other changes are made to the software, to ensure that previously working functionality has not been impacted by the changes.

The main objective of regression testing is to ensure that previously working functionality continues to work correctly after any modifications to the software. This involves re-executing test cases that were previously executed to ensure that they still pass, and also adding new test cases to cover any new functionality or changes that have been made.

Regression testing can be performed manually or using automated testing tools. Automated regression testing tools can significantly reduce the time and effort required to execute and maintain regression test suites. Automated tools can also help to identify defects and issues in the software more quickly, allowing for faster feedback and resolution.

Regression testing https://u-tor.com/services/... is a critical component of software development and is essential for ensuring that software applications remain functional and error-free, even after changes have been made to the system.

person: do you know any sites that can help with blah blah blah
me: yea one sec
me: here ya go https://blahblah.blah
person: is this a virus ?
me: no it's a site that will help you with blah
person: i'm not gonna click on that because i don't wanna get a virus.
me: but it's not a virus you can't get a virus just by clicking a link you would actually have to download something and execute it.
person: oh okay but i still don't trust it
me: uhhh okay
person : so are you gonna help me or what ?
me : ..................*scream internally*
person: okay fine your not gonna help me

Discovered this dumb backdoor into http://tutorialspoint.com/codinggro... months ago (June 2019). It's in Project>Compilation Options

It lets you execute any command on their server. I found a lot out:

The system is Red Hat based (Fedora/CentOS/RHEL)
It uses Linux kernel 3.20
It has 251GB of RAM
It has an 800GB HDD
Its IP is 172.17.0.2
Its main username is cg
It uses systemd init

I am programming a site where developers can share shell scripts and other users can execute it via a CLI.

I decided to add a little joke into it: the page where users can view a shell script is https://mukodik.com/scriptid.sh

I use Express, so I just use app.get('/:id.sh') to get the scriptid.

How would someone possibly bug out this page? (the uploaded shell script is not actually stored in a file, it's stored in a mysql database(using connection.escape to escape chars))

My another attempt to write something in rust and I wanted to try tauri as it’s promising competition to electron.

Why use tauri not electron?
Cause in tauri you can write rust plugins that you can interact with directly from javascript without stupid http servers, mangling code and stuff.

From javascript point you only call one method and pass object with arguments into it.

So it took me entire weekend to create draft plugin to interact with sqlite database.

Documentation of tauri is inconsistent. I understand that cause it’s young project and plugins architecture changed frequently.

Moreover my knowledge of rust is near to zero. But overall it was worth it. I like what I achieved.

I can pass sql query and execute it inside mutex guarded singleton. Like I said before I like it cause I can call my plugin directly from javascript.

I know I wasn’t fancy with my implementation. I just created file database connection from json configuration and managed to receive string sql statements. I just print results with rust to console for now.

I will add sending back results later this week.

For me tauri is already better then electron cause code is clear and there is no workaround ( except singleton with connection - cause of limitations of my rust knowledge ).

Live long tauri and fuck you electron.

https://tauri.studio/en/
if you’re interested.