mainline | Core web service | Web Services library

The root cause of this error is that the struct esp_netif_t is a private type in the netif implementation. You're not supposed to create any objects of this type, only pass around handles (pointers) to it.

I suspect you've misunderstood what esp_netif_get_netif_impl_name() does. According to the API doc it takes a handle to a esp_netif_t and returns the name corresponding to this interface.

What you seem to be after is retrieving the handle to your interface in the first place. For this the (rather terse) API doc suggest a few other functions, e.g. esp_netif_get_handle_from_ifkey(...) for searching for interfaces using something called interface key (no idea, sorry, but google helps there) or esp_netif_next(...) for iterating over interfaces.

According to this forum post you might want to try something like this:

The upstream repo is

That's why you usually never find prebuilt kernel module distributed somewhere. You have to build kernel module with kernel headers of your running kernel. Common practice is always having the right kernel headers in your /usr/src

The $2a at the beginning of the salt is a marker of the blowfish/bcrypt method.

Blowfish is not supported by all Linux distros, like Ubuntu:

How to make Ubuntu's crypt(3) support Blowfish?

https://bugs.launchpad.net/ubuntu/+source/linux/+bug/1349252

Debian does not support blowfish in crypt as of Debian 10 but should be able to do it in the next release, moving the dependency of crypt from glibc to libxcrypt:

https://bugs.debian.org/cgi-bin/bugreport.cgi?bug=149452#42

https://blog.bofh.it/debian/id_458

I made an attempt to use passlib with the verify context whose prototype is like crypt.crypt:

This might help

The ARM document titled Cortex-M for Beginners may provide the information you are looking for, more specifically at pages 6 and 7.

ARMv6-M provides the 16 bit instructions ADC, ADD, ADR, AND, ASR, B, BIC, BKPT, BL, BLX, BX, CMN, CMP, CPS, EOR, LDMIA, LDR, LDRB, LDRH, LDRSB, LDRSH, LSL, LSR, MOV, MUL, MVN, NOP, ORR, PUSH, REV, REV16, REVSH, ROR, RSB, SBC, SEV, STMIA, STR, STRB, STRH, SUB, SVC, SXTB, SXTH, TST, UDF, UXTB, UXTH, WFE, WFI, and YIELD.

Additionally, 32 bit instructions BL, DMB, DSB, ISB, MRS, and MSR are available.

To these, ARMv8-M baselines adds...

• hardware divide instructions SDIV and UDIV
• the 32 bit unconditional branch instruction B (for extended range)
• 16 bit compare and branch instructions CBZ and CBNZ
• 32 bit instructions MOVW and MOVT for loading constants (as an alternative to LDR Rd, =...)
• load-acquire/store-release instructions LDA, LDAB, LDAH, STL, STLB, and STLH
• load-acquire/store-release instructions with exclusive access LDAEX, LDAEXB, LDAEXH, STLEX, STLEXB, and STLEXH
• exclusive access instructions CLREX, LDREX, LDREXB, LDREXH, STREX, STREXB, and STREXH

If additionally the security extension is implemented, the instructions BLXNS, BXNS, SG, TT, TTT, TTA, and TTAT are available.

Fortunately perseverance pays off. I have found the proper documentation on the Linux Foundation website.

https://wiki.linuxfoundation.org/realtime/documentation/technical_basics/preemption_models

Which gives a nice overview. From this documentation i think the hard IRQ part is still not preemptable.

1. Is it recommended? I don't know: it seems like this would depend on who is doing the recommendations.

2. Will it create further issues? No, but it won't solve them either.

3. Is it possible to have such a configuration? Yes, of course, you demonstrated that yourself.

4. Can you configure git clone to do this? Not precisely, no: git clone --single-branch gets close though, and after doing that, you can use git remote set-branches --add to add the four remaining branches, so that instead of a single-branch clone, you have a five-branch clone.

Your best bet, though, would be to figure out why your systems are doing this. That's usually a sign of running multiple parallel git fetch operations on a single repository (don't do that!).

It sounds like you have multiple users sharing a single Git repository in which they try to do work. Don't do that! Git repositories are meant to be private to each developer.

OK, I think I know what might be happening: Like I said in my comment:

I just read your message on the mailing list and tried in one of my own projects, also using plugin version 3.1.2. Actually, just specifying false inside the was enough to avoid overwriting. I just executed the unpack goal once, then manually modified an unpacked file and it did not get overwritten. I even see my-artifact-1.3.jar already unpacked in the log.

I continued experimenting some more and noticed that even when deleting many unpacked files, they will not be recreated, so the check must be on a more global level, not on a per-file basis.

Even when deleting all files or the whole output directory, the dependency will not be unpacked again. That was a sure indicator that some kind of meta information must be stored somewhere outside the output directory. The first place to look for it was of course the target directory, and obviously enough, in subdirectory target/dependency-maven-plugin-markers there are (empty) marker files like my-dependency-1.3.marker. Deleting one of those files has the effect of the dependency getting unpacked again during the next build, overwriting possible existing files.

So the way for you to solve this problem is to avoid cleaning the target directory or at making sure to keep the corresponding marker file.

Update: You could also create the marker file by yourself if the EXE file you want to protect exists and if for some reason your build workflow needs the clean in between. But the latter would be a bit ugly, you should try to avoid it. With Antrun or some Beanshell or Groovy scripting it would be possible, though.

Somewhat more elegant would be a profile with auto-activation if the EXE file does not exist, then putting the dependency plugin inside the profile, i.e. it would only get active if the EXE does not exist in the first place.